import { mesheryBaseApi as api } from "./api";
export const addTagTypes = [
  "Meshery_Controllers_Configuration_controllers",
  "Console_API_Console",
  "Evaluation_Evaluation",
  "Registry_Registry",
  "System_API_System",
  "credential_credentials",
  "Key_users",
  "Organization_Organizations",
  "User_users",
  "Connection_API_Connections",
  "Connection_API_ConnectionDefinitions",
  "Design_designs",
  "Environment_environments",
  "Events_events",
  "Performance_Profile_performance",
  "Workspace_workspaces",
  "Workspace_designs",
  "Workspace_views",
] as const;
const injectedRtkApi = api
  .enhanceEndpoints({
    addTagTypes,
  })
  .injectEndpoints({
    endpoints: (build) => ({
      getControllersDefaultConfig: build.query<
        GetControllersDefaultConfigApiResponse,
        GetControllersDefaultConfigApiArg
      >({
        query: () => ({ url: `/api/system/controllers/config` }),
        providesTags: ["Meshery_Controllers_Configuration_controllers"],
      }),
      updateControllersDefaultConfig: build.mutation<
        UpdateControllersDefaultConfigApiResponse,
        UpdateControllersDefaultConfigApiArg
      >({
        query: (queryArg) => ({ url: `/api/system/controllers/config`, method: "PUT", body: queryArg.body }),
        invalidatesTags: ["Meshery_Controllers_Configuration_controllers"],
      }),
      getConnectionControllersConfig: build.query<
        GetConnectionControllersConfigApiResponse,
        GetConnectionControllersConfigApiArg
      >({
        query: (queryArg) => ({ url: `/api/integrations/connections/${queryArg.connectionId}/controllers/config` }),
        providesTags: ["Meshery_Controllers_Configuration_controllers"],
      }),
      updateConnectionControllersConfig: build.mutation<
        UpdateConnectionControllersConfigApiResponse,
        UpdateConnectionControllersConfigApiArg
      >({
        query: (queryArg) => ({
          url: `/api/integrations/connections/${queryArg.connectionId}/controllers/config`,
          method: "PUT",
          body: queryArg.body,
        }),
        invalidatesTags: ["Meshery_Controllers_Configuration_controllers"],
      }),
      getConsoleCapabilities: build.query<GetConsoleCapabilitiesApiResponse, GetConsoleCapabilitiesApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/connections/${queryArg.connectionId}/console/capabilities`,
          params: {
            resource: queryArg?.resource,
            name: queryArg?.name,
            namespace: queryArg?.["namespace"],
            container: queryArg?.container,
          },
        }),
        providesTags: ["Console_API_Console"],
      }),
      openTerminalConsole: build.query<OpenTerminalConsoleApiResponse, OpenTerminalConsoleApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/connections/${queryArg.connectionId}/console/terminal`,
          params: {
            resource: queryArg?.resource,
            name: queryArg?.name,
            namespace: queryArg?.["namespace"],
            container: queryArg?.container,
            command: queryArg?.command,
          },
        }),
        providesTags: ["Console_API_Console"],
      }),
      openLogConsole: build.query<OpenLogConsoleApiResponse, OpenLogConsoleApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/connections/${queryArg.connectionId}/console/logs`,
          params: {
            resource: queryArg?.resource,
            name: queryArg?.name,
            namespace: queryArg?.["namespace"],
            container: queryArg?.container,
            follow: queryArg?.follow,
            previous: queryArg?.previous,
            timestamps: queryArg?.timestamps,
            tailLines: queryArg?.tailLines,
            sinceSeconds: queryArg?.sinceSeconds,
          },
        }),
        providesTags: ["Console_API_Console"],
      }),
      evaluateRelationships: build.mutation<EvaluateRelationshipsApiResponse, EvaluateRelationshipsApiArg>({
        query: (queryArg) => ({ url: `/api/registry/relationships/evaluate`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Evaluation_Evaluation"],
      }),
      getRegistryModels: build.query<GetRegistryModelsApiResponse, GetRegistryModelsApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/models`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            status: queryArg?.status,
            id: queryArg?.id,
            registrant: queryArg?.registrant,
            version: queryArg?.version,
            annotations: queryArg?.annotations,
            components: queryArg?.components,
            relationships: queryArg?.relationships,
            trim: queryArg?.trim,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryModelsByName: build.query<GetRegistryModelsByNameApiResponse, GetRegistryModelsByNameApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/models/${queryArg.model}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            annotations: queryArg?.annotations,
            components: queryArg?.components,
            relationships: queryArg?.relationships,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      deleteRegistryModel: build.mutation<DeleteRegistryModelApiResponse, DeleteRegistryModelApiArg>({
        query: (queryArg) => ({ url: `/api/registry/models/${queryArg.model}`, method: "DELETE" }),
        invalidatesTags: ["Registry_Registry"],
      }),
      getRegistryComponentsByModel: build.query<
        GetRegistryComponentsByModelApiResponse,
        GetRegistryComponentsByModelApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/models/${queryArg.model}/components`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            apiVersion: queryArg?.apiVersion,
            trim: queryArg?.trim,
            annotations: queryArg?.annotations,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryComponentsByModelAndName: build.query<
        GetRegistryComponentsByModelAndNameApiResponse,
        GetRegistryComponentsByModelAndNameApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/models/${queryArg.model}/components/${queryArg.name}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            apiVersion: queryArg?.apiVersion,
            trim: queryArg?.trim,
            annotations: queryArg?.annotations,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryRelationshipsByModel: build.query<
        GetRegistryRelationshipsByModelApiResponse,
        GetRegistryRelationshipsByModelApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/models/${queryArg.model}/relationships`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryRelationshipsByModelAndName: build.query<
        GetRegistryRelationshipsByModelAndNameApiResponse,
        GetRegistryRelationshipsByModelAndNameApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/models/${queryArg.model}/relationships/${queryArg.name}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryPoliciesByModel: build.query<GetRegistryPoliciesByModelApiResponse, GetRegistryPoliciesByModelApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/models/${queryArg.model}/policies`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryPoliciesByModelAndName: build.query<
        GetRegistryPoliciesByModelAndNameApiResponse,
        GetRegistryPoliciesByModelAndNameApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/models/${queryArg.model}/policies/${queryArg.name}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryCategories: build.query<GetRegistryCategoriesApiResponse, GetRegistryCategoriesApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/categories`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryCategoriesByName: build.query<
        GetRegistryCategoriesByNameApiResponse,
        GetRegistryCategoriesByNameApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/categories/${queryArg.category}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryModelsByCategory: build.query<
        GetRegistryModelsByCategoryApiResponse,
        GetRegistryModelsByCategoryApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/categories/${queryArg.category}/models`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            annotations: queryArg?.annotations,
            components: queryArg?.components,
            relationships: queryArg?.relationships,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryModelsByCategoryAndModel: build.query<
        GetRegistryModelsByCategoryAndModelApiResponse,
        GetRegistryModelsByCategoryAndModelApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/categories/${queryArg.category}/models/${queryArg.model}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            annotations: queryArg?.annotations,
            components: queryArg?.components,
            relationships: queryArg?.relationships,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryComponentsByCategoryAndModel: build.query<
        GetRegistryComponentsByCategoryAndModelApiResponse,
        GetRegistryComponentsByCategoryAndModelApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/categories/${queryArg.category}/models/${queryArg.model}/components`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            apiVersion: queryArg?.apiVersion,
            trim: queryArg?.trim,
            annotations: queryArg?.annotations,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryComponentsByCategoryAndModelAndName: build.query<
        GetRegistryComponentsByCategoryAndModelAndNameApiResponse,
        GetRegistryComponentsByCategoryAndModelAndNameApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/categories/${queryArg.category}/models/${queryArg.model}/components/${queryArg.name}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            apiVersion: queryArg?.apiVersion,
            trim: queryArg?.trim,
            annotations: queryArg?.annotations,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryComponentsByCategory: build.query<
        GetRegistryComponentsByCategoryApiResponse,
        GetRegistryComponentsByCategoryApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/categories/${queryArg.category}/components`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            apiVersion: queryArg?.apiVersion,
            trim: queryArg?.trim,
            annotations: queryArg?.annotations,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryComponentsByCategoryAndName: build.query<
        GetRegistryComponentsByCategoryAndNameApiResponse,
        GetRegistryComponentsByCategoryAndNameApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/categories/${queryArg.category}/components/${queryArg.name}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            apiVersion: queryArg?.apiVersion,
            trim: queryArg?.trim,
            annotations: queryArg?.annotations,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryComponents: build.query<GetRegistryComponentsApiResponse, GetRegistryComponentsApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/components`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            apiVersion: queryArg?.apiVersion,
            trim: queryArg?.trim,
            annotations: queryArg?.annotations,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      registerRegistryComponent: build.mutation<RegisterRegistryComponentApiResponse, RegisterRegistryComponentApiArg>({
        query: (queryArg) => ({ url: `/api/registry/components`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Registry_Registry"],
      }),
      getRegistryComponentsByName: build.query<
        GetRegistryComponentsByNameApiResponse,
        GetRegistryComponentsByNameApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/components/${queryArg.name}`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
            apiVersion: queryArg?.apiVersion,
            trim: queryArg?.trim,
            annotations: queryArg?.annotations,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      getRegistryRelationships: build.query<GetRegistryRelationshipsApiResponse, GetRegistryRelationshipsApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/relationships`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
            version: queryArg?.version,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      registerRegistryRelationship: build.mutation<
        RegisterRegistryRelationshipApiResponse,
        RegisterRegistryRelationshipApiArg
      >({
        query: (queryArg) => ({ url: `/api/registry/relationships`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Registry_Registry"],
      }),
      getRegistryRegistrants: build.query<GetRegistryRegistrantsApiResponse, GetRegistryRegistrantsApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/registrants`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            sort: queryArg?.sort,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      registerRegistryEntities: build.mutation<RegisterRegistryEntitiesApiResponse, RegisterRegistryEntitiesApiArg>({
        query: (queryArg) => ({ url: `/api/registry/register`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Registry_Registry"],
      }),
      generateRegistryComponents: build.mutation<
        GenerateRegistryComponentsApiResponse,
        GenerateRegistryComponentsApiArg
      >({
        query: (queryArg) => ({ url: `/api/registry/generate`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Registry_Registry"],
      }),
      exportRegistryModel: build.query<ExportRegistryModelApiResponse, ExportRegistryModelApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/export`,
          params: {
            id: queryArg?.id,
            name: queryArg?.name,
            version: queryArg?.version,
            outputFormat: queryArg?.outputFormat,
            fileType: queryArg?.fileType,
            components: queryArg?.components,
            relationships: queryArg?.relationships,
          },
        }),
        providesTags: ["Registry_Registry"],
      }),
      validateRegistryEntities: build.mutation<ValidateRegistryEntitiesApiResponse, ValidateRegistryEntitiesApiArg>({
        query: (queryArg) => ({ url: `/api/registry/validate`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Registry_Registry"],
      }),
      updateRegistryEntityStatus: build.mutation<
        UpdateRegistryEntityStatusApiResponse,
        UpdateRegistryEntityStatusApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/${queryArg.entityType}/status`,
          method: "POST",
          body: queryArg.body,
        }),
        invalidatesTags: ["Registry_Registry"],
      }),
      getSystemDatabase: build.query<GetSystemDatabaseApiResponse, GetSystemDatabaseApiArg>({
        query: (queryArg) => ({
          url: `/api/system/database`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            sort: queryArg?.sort,
            order: queryArg?.order,
          },
        }),
        providesTags: ["System_API_System"],
      }),
      resetSystemDatabase: build.mutation<ResetSystemDatabaseApiResponse, ResetSystemDatabaseApiArg>({
        query: () => ({ url: `/api/system/database/reset`, method: "DELETE" }),
        invalidatesTags: ["System_API_System"],
      }),
      getSystemVersion: build.query<GetSystemVersionApiResponse, GetSystemVersionApiArg>({
        query: () => ({ url: `/api/system/version` }),
        providesTags: ["System_API_System"],
      }),
      addKubernetesConfig: build.mutation<AddKubernetesConfigApiResponse, AddKubernetesConfigApiArg>({
        query: (queryArg) => ({ url: `/api/system/kubernetes`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["System_API_System"],
      }),
      discoverKubernetesContexts: build.mutation<
        DiscoverKubernetesContextsApiResponse,
        DiscoverKubernetesContextsApiArg
      >({
        query: (queryArg) => ({ url: `/api/system/kubernetes/contexts`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["System_API_System"],
      }),
      pingKubernetes: build.query<PingKubernetesApiResponse, PingKubernetesApiArg>({
        query: (queryArg) => ({
          url: `/api/system/kubernetes/ping`,
          params: {
            connectionId: queryArg?.connectionId,
          },
        }),
        providesTags: ["System_API_System"],
      }),
      getSystemSync: build.query<GetSystemSyncApiResponse, GetSystemSyncApiArg>({
        query: () => ({ url: `/api/system/sync` }),
        providesTags: ["System_API_System"],
      }),
      getOperatorControllerStatus: build.query<
        GetOperatorControllerStatusApiResponse,
        GetOperatorControllerStatusApiArg
      >({
        query: (queryArg) => ({
          url: `/api/system/controllers/operator/status`,
          params: {
            connectionId: queryArg?.connectionId,
          },
        }),
        providesTags: ["System_API_System"],
      }),
      getMeshsyncControllerStatus: build.query<
        GetMeshsyncControllerStatusApiResponse,
        GetMeshsyncControllerStatusApiArg
      >({
        query: (queryArg) => ({
          url: `/api/system/controllers/meshsync/status`,
          params: {
            connectionId: queryArg?.connectionId,
          },
        }),
        providesTags: ["System_API_System"],
      }),
      getBrokerControllerStatus: build.query<GetBrokerControllerStatusApiResponse, GetBrokerControllerStatusApiArg>({
        query: (queryArg) => ({
          url: `/api/system/controllers/broker/status`,
          params: {
            connectionId: queryArg?.connectionId,
          },
        }),
        providesTags: ["System_API_System"],
      }),
      getControllerDiagnostics: build.query<GetControllerDiagnosticsApiResponse, GetControllerDiagnosticsApiArg>({
        query: (queryArg) => ({
          url: `/api/system/controllers/diagnostics`,
          params: {
            connectionId: queryArg?.connectionId,
          },
        }),
        providesTags: ["System_API_System"],
      }),
      subscribeControllersStatus: build.query<SubscribeControllersStatusApiResponse, SubscribeControllersStatusApiArg>({
        query: (queryArg) => ({
          url: `/api/system/controllers/status/subscribe`,
          params: {
            connectionIds: queryArg?.connectionIds,
          },
        }),
        providesTags: ["System_API_System"],
      }),
      getUserCredentials: build.query<GetUserCredentialsApiResponse, GetUserCredentialsApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/credentials`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
            search: queryArg?.search,
            order: queryArg?.order,
          },
        }),
        providesTags: ["credential_credentials"],
      }),
      saveUserCredential: build.mutation<SaveUserCredentialApiResponse, SaveUserCredentialApiArg>({
        query: (queryArg) => ({ url: `/api/integrations/credentials`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["credential_credentials"],
      }),
      updateUserCredential: build.mutation<UpdateUserCredentialApiResponse, UpdateUserCredentialApiArg>({
        query: (queryArg) => ({ url: `/api/integrations/credentials`, method: "PUT", body: queryArg.body }),
        invalidatesTags: ["credential_credentials"],
      }),
      deleteUserCredential: build.mutation<DeleteUserCredentialApiResponse, DeleteUserCredentialApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/credentials`,
          method: "DELETE",
          params: {
            credentialId: queryArg?.credentialId,
          },
        }),
        invalidatesTags: ["credential_credentials"],
      }),
      getCredentialById: build.query<GetCredentialByIdApiResponse, GetCredentialByIdApiArg>({
        query: (queryArg) => ({ url: `/api/integrations/credentials/${queryArg.credentialId}` }),
        providesTags: ["credential_credentials"],
      }),
      getUserKeys: build.query<GetUserKeysApiResponse, GetUserKeysApiArg>({
        query: (queryArg) => ({
          url: `/api/identity/orgs/${queryArg.orgId}/users/keys`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
          },
        }),
        providesTags: ["Key_users"],
      }),
      getOrgs: build.query<GetOrgsApiResponse, GetOrgsApiArg>({
        query: (queryArg) => ({
          url: `/api/identity/orgs`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            all: queryArg?.all,
          },
        }),
        providesTags: ["Organization_Organizations"],
      }),
      createOrg: build.mutation<CreateOrgApiResponse, CreateOrgApiArg>({
        query: (queryArg) => ({ url: `/api/identity/orgs`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Organization_Organizations"],
      }),
      getOrgByDomain: build.query<GetOrgByDomainApiResponse, GetOrgByDomainApiArg>({
        query: (queryArg) => ({
          url: `/api/identity/orgs/by-domain`,
          params: {
            domain: queryArg?.domain,
          },
        }),
        providesTags: ["Organization_Organizations"],
      }),
      getOrg: build.query<GetOrgApiResponse, GetOrgApiArg>({
        query: (queryArg) => ({ url: `/api/identity/orgs/${queryArg.orgId}` }),
        providesTags: ["Organization_Organizations"],
      }),
      deleteOrg: build.mutation<DeleteOrgApiResponse, DeleteOrgApiArg>({
        query: (queryArg) => ({ url: `/api/identity/orgs/${queryArg.orgId}`, method: "DELETE" }),
        invalidatesTags: ["Organization_Organizations"],
      }),
      updateOrg: build.mutation<UpdateOrgApiResponse, UpdateOrgApiArg>({
        query: (queryArg) => ({ url: `/api/identity/orgs/${queryArg.orgId}`, method: "PUT", body: queryArg.body }),
        invalidatesTags: ["Organization_Organizations"],
      }),
      getOrgPreferences: build.query<GetOrgPreferencesApiResponse, GetOrgPreferencesApiArg>({
        query: (queryArg) => ({ url: `/api/identity/orgs/${queryArg.orgId}/preferences` }),
        providesTags: ["Organization_Organizations"],
      }),
      addTeamToOrg: build.mutation<AddTeamToOrgApiResponse, AddTeamToOrgApiArg>({
        query: (queryArg) => ({
          url: `/api/identity/orgs/${queryArg.orgId}/teams/${queryArg.teamId}`,
          method: "POST",
          body: queryArg.body,
        }),
        invalidatesTags: ["Organization_Organizations"],
      }),
      removeTeamFromOrg: build.mutation<RemoveTeamFromOrgApiResponse, RemoveTeamFromOrgApiArg>({
        query: (queryArg) => ({
          url: `/api/identity/orgs/${queryArg.orgId}/teams/${queryArg.teamId}/remove`,
          method: "POST",
        }),
        invalidatesTags: ["Organization_Organizations"],
      }),
      addUserToOrg: build.mutation<AddUserToOrgApiResponse, AddUserToOrgApiArg>({
        query: (queryArg) => ({ url: `/api/identity/orgs/${queryArg.orgId}/users/${queryArg.userId}`, method: "POST" }),
        invalidatesTags: ["Organization_Organizations"],
      }),
      deleteUserFromOrg: build.mutation<DeleteUserFromOrgApiResponse, DeleteUserFromOrgApiArg>({
        query: (queryArg) => ({
          url: `/api/identity/orgs/${queryArg.orgId}/users/${queryArg.userId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Organization_Organizations"],
      }),
      getUsersForOrg: build.query<GetUsersForOrgApiResponse, GetUsersForOrgApiArg>({
        query: (queryArg) => ({
          url: `/api/identity/orgs/${queryArg.orgId}/users`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            filter: queryArg?.filter,
            teamId: queryArg?.teamId,
          },
        }),
        providesTags: ["User_users"],
      }),
      getUserProfileById: build.query<GetUserProfileByIdApiResponse, GetUserProfileByIdApiArg>({
        query: (queryArg) => ({ url: `/api/identity/users/profile/${queryArg.id}` }),
        providesTags: ["User_users"],
      }),
      getUser: build.query<GetUserApiResponse, GetUserApiArg>({
        query: () => ({ url: `/api/identity/users/profile` }),
        providesTags: ["User_users"],
      }),
      getUserEmailAddresses: build.query<GetUserEmailAddressesApiResponse, GetUserEmailAddressesApiArg>({
        query: (queryArg) => ({ url: `/api/identity/users/${queryArg.userId}/emails` }),
        providesTags: ["User_users"],
      }),
      getConnections: build.query<GetConnectionsApiResponse, GetConnectionsApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/connections`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            orgId: queryArg?.orgId,
            filter: queryArg?.filter,
            kind: queryArg?.kind,
            status: queryArg?.status,
            type: queryArg?.["type"],
            name: queryArg?.name,
          },
        }),
        providesTags: ["Connection_API_Connections"],
      }),
      registerConnection: build.mutation<RegisterConnectionApiResponse, RegisterConnectionApiArg>({
        query: (queryArg) => ({ url: `/api/integrations/connections`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      processConnectionRegistration: build.mutation<
        ProcessConnectionRegistrationApiResponse,
        ProcessConnectionRegistrationApiArg
      >({
        query: (queryArg) => ({ url: `/api/integrations/connections/register`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      cancelConnectionRegister: build.mutation<CancelConnectionRegisterApiResponse, CancelConnectionRegisterApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/connections/register/${queryArg.registrationId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      getConnectionById: build.query<GetConnectionByIdApiResponse, GetConnectionByIdApiArg>({
        query: (queryArg) => ({ url: `/api/integrations/connections/${queryArg.connectionId}` }),
        providesTags: ["Connection_API_Connections"],
      }),
      updateConnection: build.mutation<UpdateConnectionApiResponse, UpdateConnectionApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/connections/${queryArg.connectionId}`,
          method: "PUT",
          body: queryArg.body,
        }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      deleteConnection: build.mutation<DeleteConnectionApiResponse, DeleteConnectionApiArg>({
        query: (queryArg) => ({ url: `/api/integrations/connections/${queryArg.connectionId}`, method: "DELETE" }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      performConnectionAction: build.mutation<PerformConnectionActionApiResponse, PerformConnectionActionApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/connections/${queryArg.connectionId}/actions`,
          method: "POST",
          body: queryArg.body,
        }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      deleteMesheryConnection: build.mutation<DeleteMesheryConnectionApiResponse, DeleteMesheryConnectionApiArg>({
        query: (queryArg) => ({
          url: `/api/integrations/connections/meshery/${queryArg.mesheryServerId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      getKubernetesContext: build.query<GetKubernetesContextApiResponse, GetKubernetesContextApiArg>({
        query: (queryArg) => ({ url: `/api/integrations/connections/kubernetes/${queryArg.connectionId}/context` }),
        providesTags: ["Connection_API_Connections"],
      }),
      addConnectionToEnvironment: build.mutation<
        AddConnectionToEnvironmentApiResponse,
        AddConnectionToEnvironmentApiArg
      >({
        query: (queryArg) => ({
          url: `/api/environments/${queryArg.environmentId}/connections/${queryArg.connectionId}`,
          method: "POST",
        }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      removeConnectionFromEnvironment: build.mutation<
        RemoveConnectionFromEnvironmentApiResponse,
        RemoveConnectionFromEnvironmentApiArg
      >({
        query: (queryArg) => ({
          url: `/api/environments/${queryArg.environmentId}/connections/${queryArg.connectionId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Connection_API_Connections"],
      }),
      listConnectionDefinitions: build.query<ListConnectionDefinitionsApiResponse, ListConnectionDefinitionsApiArg>({
        query: (queryArg) => ({
          url: `/api/registry/connections`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            model: queryArg?.model,
            kind: queryArg?.kind,
          },
        }),
        providesTags: ["Connection_API_ConnectionDefinitions"],
      }),
      registerConnectionDefinition: build.mutation<
        RegisterConnectionDefinitionApiResponse,
        RegisterConnectionDefinitionApiArg
      >({
        query: (queryArg) => ({ url: `/api/registry/connections`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Connection_API_ConnectionDefinitions"],
      }),
      getConnectionDefinition: build.query<GetConnectionDefinitionApiResponse, GetConnectionDefinitionApiArg>({
        query: (queryArg) => ({ url: `/api/registry/connections/${queryArg.connectionDefinitionId}` }),
        providesTags: ["Connection_API_ConnectionDefinitions"],
      }),
      updateConnectionDefinition: build.mutation<
        UpdateConnectionDefinitionApiResponse,
        UpdateConnectionDefinitionApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/connections/${queryArg.connectionDefinitionId}`,
          method: "PUT",
          body: queryArg.body,
        }),
        invalidatesTags: ["Connection_API_ConnectionDefinitions"],
      }),
      deleteConnectionDefinition: build.mutation<
        DeleteConnectionDefinitionApiResponse,
        DeleteConnectionDefinitionApiArg
      >({
        query: (queryArg) => ({
          url: `/api/registry/connections/${queryArg.connectionDefinitionId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Connection_API_ConnectionDefinitions"],
      }),
      importDesign: build.mutation<ImportDesignApiResponse, ImportDesignApiArg>({
        query: (queryArg) => ({ url: `/api/pattern/import`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Design_designs"],
      }),
      createEnvironment: build.mutation<CreateEnvironmentApiResponse, CreateEnvironmentApiArg>({
        query: (queryArg) => ({ url: `/api/environments`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Environment_environments"],
      }),
      getEnvironments: build.query<GetEnvironmentsApiResponse, GetEnvironmentsApiArg>({
        query: (queryArg) => ({
          url: `/api/environments`,
          params: {
            search: queryArg?.search,
            order: queryArg?.order,
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
            orgId: queryArg?.orgId,
          },
        }),
        providesTags: ["Environment_environments"],
      }),
      getEnvironmentById: build.query<GetEnvironmentByIdApiResponse, GetEnvironmentByIdApiArg>({
        query: (queryArg) => ({
          url: `/api/environments/${queryArg.environmentId}`,
          params: {
            orgId: queryArg?.orgId,
          },
        }),
        providesTags: ["Environment_environments"],
      }),
      updateEnvironment: build.mutation<UpdateEnvironmentApiResponse, UpdateEnvironmentApiArg>({
        query: (queryArg) => ({
          url: `/api/environments/${queryArg.environmentId}`,
          method: "PUT",
          body: queryArg.body,
        }),
        invalidatesTags: ["Environment_environments"],
      }),
      deleteEnvironment: build.mutation<DeleteEnvironmentApiResponse, DeleteEnvironmentApiArg>({
        query: (queryArg) => ({ url: `/api/environments/${queryArg.environmentId}`, method: "DELETE" }),
        invalidatesTags: ["Environment_environments"],
      }),
      getEnvironmentConnections: build.query<GetEnvironmentConnectionsApiResponse, GetEnvironmentConnectionsApiArg>({
        query: (queryArg) => ({
          url: `/api/environments/${queryArg.environmentId}/connections`,
          params: {
            search: queryArg?.search,
            order: queryArg?.order,
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
            filter: queryArg?.filter,
          },
        }),
        providesTags: ["Environment_environments"],
      }),
      deleteEvent: build.mutation<DeleteEventApiResponse, DeleteEventApiArg>({
        query: (queryArg) => ({ url: `/api/events/${queryArg.eventId}`, method: "DELETE" }),
        invalidatesTags: ["Events_events"],
      }),
      bulkDeleteEvents: build.mutation<BulkDeleteEventsApiResponse, BulkDeleteEventsApiArg>({
        query: (queryArg) => ({ url: `/api/events/delete`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Events_events"],
      }),
      bulkUpdateEventStatus: build.mutation<BulkUpdateEventStatusApiResponse, BulkUpdateEventStatusApiArg>({
        query: (queryArg) => ({ url: `/api/events/status`, method: "PUT", body: queryArg.body }),
        invalidatesTags: ["Events_events"],
      }),
      updateEventStatus: build.mutation<UpdateEventStatusApiResponse, UpdateEventStatusApiArg>({
        query: (queryArg) => ({ url: `/api/events/${queryArg.eventId}/status`, method: "PUT", body: queryArg.body }),
        invalidatesTags: ["Events_events"],
      }),
      createEvent: build.mutation<CreateEventApiResponse, CreateEventApiArg>({
        query: (queryArg) => ({ url: `/api/events`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Events_events"],
      }),
      getPerformanceProfiles: build.query<GetPerformanceProfilesApiResponse, GetPerformanceProfilesApiArg>({
        query: (queryArg) => ({
          url: `/api/performance/profiles`,
          params: {
            page: queryArg?.page,
            pagesize: queryArg?.pagesize,
            search: queryArg?.search,
            order: queryArg?.order,
          },
        }),
        providesTags: ["Performance_Profile_performance"],
      }),
      upsertPerformanceProfile: build.mutation<UpsertPerformanceProfileApiResponse, UpsertPerformanceProfileApiArg>({
        query: (queryArg) => ({ url: `/api/performance/profiles`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Performance_Profile_performance"],
      }),
      getPerformanceProfile: build.query<GetPerformanceProfileApiResponse, GetPerformanceProfileApiArg>({
        query: (queryArg) => ({ url: `/api/performance/profiles/${queryArg.performanceProfileId}` }),
        providesTags: ["Performance_Profile_performance"],
      }),
      updatePerformanceProfile: build.mutation<UpdatePerformanceProfileApiResponse, UpdatePerformanceProfileApiArg>({
        query: (queryArg) => ({
          url: `/api/performance/profiles/${queryArg.performanceProfileId}`,
          method: "PUT",
          body: queryArg.body,
        }),
        invalidatesTags: ["Performance_Profile_performance"],
      }),
      deletePerformanceProfile: build.mutation<DeletePerformanceProfileApiResponse, DeletePerformanceProfileApiArg>({
        query: (queryArg) => ({ url: `/api/performance/profiles/${queryArg.performanceProfileId}`, method: "DELETE" }),
        invalidatesTags: ["Performance_Profile_performance"],
      }),
      getPerformanceProfileResults: build.query<
        GetPerformanceProfileResultsApiResponse,
        GetPerformanceProfileResultsApiArg
      >({
        query: (queryArg) => ({
          url: `/api/performance/profiles/${queryArg.performanceProfileId}/results`,
          params: {
            page: queryArg?.page,
            pagesize: queryArg?.pagesize,
            search: queryArg?.search,
            order: queryArg?.order,
          },
        }),
        providesTags: ["Performance_Profile_performance"],
      }),
      getPerformanceResults: build.query<GetPerformanceResultsApiResponse, GetPerformanceResultsApiArg>({
        query: (queryArg) => ({
          url: `/api/performance/results`,
          params: {
            page: queryArg?.page,
            pagesize: queryArg?.pagesize,
            search: queryArg?.search,
            order: queryArg?.order,
            from: queryArg?.["from"],
            to: queryArg?.to,
          },
        }),
        providesTags: ["Performance_Profile_performance"],
      }),
      getUsers: build.query<GetUsersApiResponse, GetUsersApiArg>({
        query: (queryArg) => ({
          url: `/api/users`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            filter: queryArg?.filter,
          },
        }),
        providesTags: ["User_users"],
      }),
      searchUsers: build.query<SearchUsersApiResponse, SearchUsersApiArg>({
        query: (queryArg) => ({
          url: `/api/identity/users/search`,
          params: {
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            search: queryArg?.search,
            order: queryArg?.order,
            filter: queryArg?.filter,
          },
        }),
        providesTags: ["User_users"],
      }),
      getWorkspaces: build.query<GetWorkspacesApiResponse, GetWorkspacesApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces`,
          params: {
            orgId: queryArg?.orgId,
            search: queryArg?.search,
            order: queryArg?.order,
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
            filter: queryArg?.filter,
          },
        }),
        providesTags: ["Workspace_workspaces"],
      }),
      createWorkspace: build.mutation<CreateWorkspaceApiResponse, CreateWorkspaceApiArg>({
        query: (queryArg) => ({ url: `/api/workspaces`, method: "POST", body: queryArg.body }),
        invalidatesTags: ["Workspace_workspaces"],
      }),
      getWorkspaceById: build.query<GetWorkspaceByIdApiResponse, GetWorkspaceByIdApiArg>({
        query: (queryArg) => ({ url: `/api/workspaces/${queryArg.workspaceId}` }),
        providesTags: ["Workspace_workspaces"],
      }),
      updateWorkspace: build.mutation<UpdateWorkspaceApiResponse, UpdateWorkspaceApiArg>({
        query: (queryArg) => ({ url: `/api/workspaces/${queryArg.workspaceId}`, method: "PUT", body: queryArg.body }),
        invalidatesTags: ["Workspace_workspaces"],
      }),
      deleteWorkspace: build.mutation<DeleteWorkspaceApiResponse, DeleteWorkspaceApiArg>({
        query: (queryArg) => ({ url: `/api/workspaces/${queryArg.workspaceId}`, method: "DELETE" }),
        invalidatesTags: ["Workspace_workspaces"],
      }),
      getTeamsOfWorkspace: build.query<GetTeamsOfWorkspaceApiResponse, GetTeamsOfWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/teams`,
          params: {
            search: queryArg?.search,
            order: queryArg?.order,
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
            filter: queryArg?.filter,
          },
        }),
        providesTags: ["Workspace_workspaces"],
      }),
      assignTeamToWorkspace: build.mutation<AssignTeamToWorkspaceApiResponse, AssignTeamToWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/teams/${queryArg.teamId}`,
          method: "POST",
        }),
        invalidatesTags: ["Workspace_workspaces"],
      }),
      unassignTeamFromWorkspace: build.mutation<UnassignTeamFromWorkspaceApiResponse, UnassignTeamFromWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/teams/${queryArg.teamId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Workspace_workspaces"],
      }),
      getEnvironmentsOfWorkspace: build.query<GetEnvironmentsOfWorkspaceApiResponse, GetEnvironmentsOfWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/environments`,
          params: {
            search: queryArg?.search,
            order: queryArg?.order,
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
            filter: queryArg?.filter,
          },
        }),
        providesTags: ["Workspace_workspaces"],
      }),
      assignEnvironmentToWorkspace: build.mutation<
        AssignEnvironmentToWorkspaceApiResponse,
        AssignEnvironmentToWorkspaceApiArg
      >({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/environments/${queryArg.environmentId}`,
          method: "POST",
        }),
        invalidatesTags: ["Workspace_workspaces"],
      }),
      unassignEnvironmentFromWorkspace: build.mutation<
        UnassignEnvironmentFromWorkspaceApiResponse,
        UnassignEnvironmentFromWorkspaceApiArg
      >({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/environments/${queryArg.environmentId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Workspace_workspaces"],
      }),
      getDesignsOfWorkspace: build.query<GetDesignsOfWorkspaceApiResponse, GetDesignsOfWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/designs`,
          params: {
            search: queryArg?.search,
            order: queryArg?.order,
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
            filter: queryArg?.filter,
          },
        }),
        providesTags: ["Workspace_workspaces", "Workspace_designs"],
      }),
      assignDesignToWorkspace: build.mutation<AssignDesignToWorkspaceApiResponse, AssignDesignToWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/designs/${queryArg.designId}`,
          method: "POST",
        }),
        invalidatesTags: ["Workspace_workspaces", "Workspace_designs"],
      }),
      unassignDesignFromWorkspace: build.mutation<
        UnassignDesignFromWorkspaceApiResponse,
        UnassignDesignFromWorkspaceApiArg
      >({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/designs/${queryArg.designId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Workspace_workspaces", "Workspace_designs"],
      }),
      getViewsOfWorkspace: build.query<GetViewsOfWorkspaceApiResponse, GetViewsOfWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/views`,
          params: {
            search: queryArg?.search,
            order: queryArg?.order,
            page: queryArg?.page,
            pageSize: queryArg?.pageSize,
            pagesize: queryArg?.pagesize,
            filter: queryArg?.filter,
          },
        }),
        providesTags: ["Workspace_workspaces", "Workspace_views"],
      }),
      assignViewToWorkspace: build.mutation<AssignViewToWorkspaceApiResponse, AssignViewToWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/views/${queryArg.viewId}`,
          method: "POST",
        }),
        invalidatesTags: ["Workspace_workspaces", "Workspace_views"],
      }),
      unassignViewFromWorkspace: build.mutation<UnassignViewFromWorkspaceApiResponse, UnassignViewFromWorkspaceApiArg>({
        query: (queryArg) => ({
          url: `/api/workspaces/${queryArg.workspaceId}/views/${queryArg.viewId}`,
          method: "DELETE",
        }),
        invalidatesTags: ["Workspace_workspaces", "Workspace_views"],
      }),
    }),
    overrideExisting: false,
  });
export { injectedRtkApi as mesheryApi, injectedRtkApi };
export type GetControllersDefaultConfigApiResponse = /** status 200 Server-wide controllers configuration defaults */ {
  /** Specifies the version of the schema used for this configuration document. */
  schemaVersion: string;
  /** Configuration for the Meshery Operator on the managed cluster. */
  operator?: {
    /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
    deploymentMode?: "operator" | "embedded";
    /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
    version?: string;
  };
  /** Configuration for the MeshSync agent on the managed cluster. */
  meshsync?: {
    /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
    version?: string;
    /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
    replicas?: number;
    /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
    watchList?: {
      /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
      whitelist?: {
        /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
        resource: string;
        /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
        events?: ("ADDED" | "MODIFIED" | "DELETED")[];
      }[];
      /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
      blacklist?: string[];
    };
    /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
    outputNamespaces?: string[];
    /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
    outputResources?: string[];
    /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
    redactSecrets?: boolean;
    /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
    brokerContentDedup?: boolean;
    /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
    debugLogging?: boolean;
  };
  /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
  broker?: {
    /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
    version?: string;
    /** Number of NATS server replicas (Broker custom resource spec.size). */
    replicas?: number;
    /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
    service?: {
      /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
      type?: "ClusterIP" | "NodePort" | "LoadBalancer";
      /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
      annotations?: {
        [key: string]: string;
      };
      /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
      loadBalancerClass?: string;
      /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
      loadBalancerSourceRanges?: string[];
      /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
      externalEndpointOverride?: string;
    };
  };
};
export type GetControllersDefaultConfigApiArg = void;
export type UpdateControllersDefaultConfigApiResponse =
  /** status 200 Persisted server-wide controllers configuration defaults */ {
    /** Specifies the version of the schema used for this configuration document. */
    schemaVersion: string;
    /** Configuration for the Meshery Operator on the managed cluster. */
    operator?: {
      /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
      deploymentMode?: "operator" | "embedded";
      /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
      version?: string;
    };
    /** Configuration for the MeshSync agent on the managed cluster. */
    meshsync?: {
      /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
      version?: string;
      /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
      replicas?: number;
      /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
      watchList?: {
        /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
        whitelist?: {
          /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
          resource: string;
          /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
          events?: ("ADDED" | "MODIFIED" | "DELETED")[];
        }[];
        /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
        blacklist?: string[];
      };
      /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
      outputNamespaces?: string[];
      /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
      outputResources?: string[];
      /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
      redactSecrets?: boolean;
      /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
      brokerContentDedup?: boolean;
      /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
      debugLogging?: boolean;
    };
    /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
    broker?: {
      /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
      version?: string;
      /** Number of NATS server replicas (Broker custom resource spec.size). */
      replicas?: number;
      /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
      service?: {
        /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
        type?: "ClusterIP" | "NodePort" | "LoadBalancer";
        /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
        annotations?: {
          [key: string]: string;
        };
        /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
        loadBalancerClass?: string;
        /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
        loadBalancerSourceRanges?: string[];
        /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
        externalEndpointOverride?: string;
      };
    };
  };
export type UpdateControllersDefaultConfigApiArg = {
  /** Controllers configuration document. Absent fields inherit from the next precedence layer. */
  body: {
    /** Configuration for the Meshery Operator on the managed cluster. */
    operator?: {
      /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
      deploymentMode?: "operator" | "embedded";
      /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
      version?: string;
    };
    /** Configuration for the MeshSync agent on the managed cluster. */
    meshsync?: {
      /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
      version?: string;
      /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
      replicas?: number;
      /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
      watchList?: {
        /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
        whitelist?: {
          /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
          resource: string;
          /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
          events?: ("ADDED" | "MODIFIED" | "DELETED")[];
        }[];
        /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
        blacklist?: string[];
      };
      /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
      outputNamespaces?: string[];
      /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
      outputResources?: string[];
      /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
      redactSecrets?: boolean;
      /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
      brokerContentDedup?: boolean;
      /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
      debugLogging?: boolean;
    };
    /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
    broker?: {
      /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
      version?: string;
      /** Number of NATS server replicas (Broker custom resource spec.size). */
      replicas?: number;
      /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
      service?: {
        /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
        type?: "ClusterIP" | "NodePort" | "LoadBalancer";
        /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
        annotations?: {
          [key: string]: string;
        };
        /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
        loadBalancerClass?: string;
        /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
        loadBalancerSourceRanges?: string[];
        /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
        externalEndpointOverride?: string;
      };
    };
  };
};
export type GetConnectionControllersConfigApiResponse = /** status 200 Controllers configuration for the connection */ {
  /** Deployment and runtime configuration for the Meshery controllers that manage a Kubernetes connection: Meshery Operator, MeshSync, and Meshery Broker. The same document shape is used at two layers. As a server-wide default it declares how Meshery Server deploys and configures the controllers for every managed cluster. As a per-connection override, stored in the connection's metadata, it overrides the server-wide default for a single connection. Every configuration field is optional: an absent field inherits the value from the next layer (per-connection override, then server-wide default, then built-in default). The only required field is the server-stamped schemaVersion discriminator, which identifies the document revision for future migrations. Learn more at https://docs.meshery.io/concepts/architecture */
  override?: {
    /** Specifies the version of the schema used for this configuration document. */
    schemaVersion: string;
    /** Configuration for the Meshery Operator on the managed cluster. */
    operator?: {
      /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
      deploymentMode?: "operator" | "embedded";
      /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
      version?: string;
    };
    /** Configuration for the MeshSync agent on the managed cluster. */
    meshsync?: {
      /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
      version?: string;
      /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
      replicas?: number;
      /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
      watchList?: {
        /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
        whitelist?: {
          /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
          resource: string;
          /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
          events?: ("ADDED" | "MODIFIED" | "DELETED")[];
        }[];
        /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
        blacklist?: string[];
      };
      /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
      outputNamespaces?: string[];
      /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
      outputResources?: string[];
      /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
      redactSecrets?: boolean;
      /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
      brokerContentDedup?: boolean;
      /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
      debugLogging?: boolean;
    };
    /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
    broker?: {
      /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
      version?: string;
      /** Number of NATS server replicas (Broker custom resource spec.size). */
      replicas?: number;
      /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
      service?: {
        /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
        type?: "ClusterIP" | "NodePort" | "LoadBalancer";
        /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
        annotations?: {
          [key: string]: string;
        };
        /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
        loadBalancerClass?: string;
        /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
        loadBalancerSourceRanges?: string[];
        /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
        externalEndpointOverride?: string;
      };
    };
  };
  /** Deployment and runtime configuration for the Meshery controllers that manage a Kubernetes connection: Meshery Operator, MeshSync, and Meshery Broker. The same document shape is used at two layers. As a server-wide default it declares how Meshery Server deploys and configures the controllers for every managed cluster. As a per-connection override, stored in the connection's metadata, it overrides the server-wide default for a single connection. Every configuration field is optional: an absent field inherits the value from the next layer (per-connection override, then server-wide default, then built-in default). The only required field is the server-stamped schemaVersion discriminator, which identifies the document revision for future migrations. Learn more at https://docs.meshery.io/concepts/architecture */
  default?: {
    /** Specifies the version of the schema used for this configuration document. */
    schemaVersion: string;
    /** Configuration for the Meshery Operator on the managed cluster. */
    operator?: {
      /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
      deploymentMode?: "operator" | "embedded";
      /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
      version?: string;
    };
    /** Configuration for the MeshSync agent on the managed cluster. */
    meshsync?: {
      /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
      version?: string;
      /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
      replicas?: number;
      /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
      watchList?: {
        /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
        whitelist?: {
          /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
          resource: string;
          /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
          events?: ("ADDED" | "MODIFIED" | "DELETED")[];
        }[];
        /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
        blacklist?: string[];
      };
      /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
      outputNamespaces?: string[];
      /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
      outputResources?: string[];
      /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
      redactSecrets?: boolean;
      /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
      brokerContentDedup?: boolean;
      /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
      debugLogging?: boolean;
    };
    /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
    broker?: {
      /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
      version?: string;
      /** Number of NATS server replicas (Broker custom resource spec.size). */
      replicas?: number;
      /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
      service?: {
        /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
        type?: "ClusterIP" | "NodePort" | "LoadBalancer";
        /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
        annotations?: {
          [key: string]: string;
        };
        /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
        loadBalancerClass?: string;
        /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
        loadBalancerSourceRanges?: string[];
        /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
        externalEndpointOverride?: string;
      };
    };
  };
  /** Deployment and runtime configuration for the Meshery controllers that manage a Kubernetes connection: Meshery Operator, MeshSync, and Meshery Broker. The same document shape is used at two layers. As a server-wide default it declares how Meshery Server deploys and configures the controllers for every managed cluster. As a per-connection override, stored in the connection's metadata, it overrides the server-wide default for a single connection. Every configuration field is optional: an absent field inherits the value from the next layer (per-connection override, then server-wide default, then built-in default). The only required field is the server-stamped schemaVersion discriminator, which identifies the document revision for future migrations. Learn more at https://docs.meshery.io/concepts/architecture */
  effective: {
    /** Specifies the version of the schema used for this configuration document. */
    schemaVersion: string;
    /** Configuration for the Meshery Operator on the managed cluster. */
    operator?: {
      /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
      deploymentMode?: "operator" | "embedded";
      /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
      version?: string;
    };
    /** Configuration for the MeshSync agent on the managed cluster. */
    meshsync?: {
      /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
      version?: string;
      /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
      replicas?: number;
      /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
      watchList?: {
        /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
        whitelist?: {
          /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
          resource: string;
          /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
          events?: ("ADDED" | "MODIFIED" | "DELETED")[];
        }[];
        /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
        blacklist?: string[];
      };
      /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
      outputNamespaces?: string[];
      /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
      outputResources?: string[];
      /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
      redactSecrets?: boolean;
      /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
      brokerContentDedup?: boolean;
      /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
      debugLogging?: boolean;
    };
    /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
    broker?: {
      /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
      version?: string;
      /** Number of NATS server replicas (Broker custom resource spec.size). */
      replicas?: number;
      /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
      service?: {
        /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
        type?: "ClusterIP" | "NodePort" | "LoadBalancer";
        /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
        annotations?: {
          [key: string]: string;
        };
        /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
        loadBalancerClass?: string;
        /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
        loadBalancerSourceRanges?: string[];
        /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
        externalEndpointOverride?: string;
      };
    };
  };
};
export type GetConnectionControllersConfigApiArg = {
  /** Kubernetes connection ID. */
  connectionId: string;
};
export type UpdateConnectionControllersConfigApiResponse =
  /** status 200 Updated controllers configuration for the connection */ {
    /** Deployment and runtime configuration for the Meshery controllers that manage a Kubernetes connection: Meshery Operator, MeshSync, and Meshery Broker. The same document shape is used at two layers. As a server-wide default it declares how Meshery Server deploys and configures the controllers for every managed cluster. As a per-connection override, stored in the connection's metadata, it overrides the server-wide default for a single connection. Every configuration field is optional: an absent field inherits the value from the next layer (per-connection override, then server-wide default, then built-in default). The only required field is the server-stamped schemaVersion discriminator, which identifies the document revision for future migrations. Learn more at https://docs.meshery.io/concepts/architecture */
    override?: {
      /** Specifies the version of the schema used for this configuration document. */
      schemaVersion: string;
      /** Configuration for the Meshery Operator on the managed cluster. */
      operator?: {
        /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
        deploymentMode?: "operator" | "embedded";
        /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
        version?: string;
      };
      /** Configuration for the MeshSync agent on the managed cluster. */
      meshsync?: {
        /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
        version?: string;
        /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
        replicas?: number;
        /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
        watchList?: {
          /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
          whitelist?: {
            /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
            resource: string;
            /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
            events?: ("ADDED" | "MODIFIED" | "DELETED")[];
          }[];
          /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
          blacklist?: string[];
        };
        /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
        outputNamespaces?: string[];
        /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
        outputResources?: string[];
        /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
        redactSecrets?: boolean;
        /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
        brokerContentDedup?: boolean;
        /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
        debugLogging?: boolean;
      };
      /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
      broker?: {
        /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
        version?: string;
        /** Number of NATS server replicas (Broker custom resource spec.size). */
        replicas?: number;
        /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
        service?: {
          /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
          type?: "ClusterIP" | "NodePort" | "LoadBalancer";
          /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
          annotations?: {
            [key: string]: string;
          };
          /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
          loadBalancerClass?: string;
          /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
          loadBalancerSourceRanges?: string[];
          /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
          externalEndpointOverride?: string;
        };
      };
    };
    /** Deployment and runtime configuration for the Meshery controllers that manage a Kubernetes connection: Meshery Operator, MeshSync, and Meshery Broker. The same document shape is used at two layers. As a server-wide default it declares how Meshery Server deploys and configures the controllers for every managed cluster. As a per-connection override, stored in the connection's metadata, it overrides the server-wide default for a single connection. Every configuration field is optional: an absent field inherits the value from the next layer (per-connection override, then server-wide default, then built-in default). The only required field is the server-stamped schemaVersion discriminator, which identifies the document revision for future migrations. Learn more at https://docs.meshery.io/concepts/architecture */
    default?: {
      /** Specifies the version of the schema used for this configuration document. */
      schemaVersion: string;
      /** Configuration for the Meshery Operator on the managed cluster. */
      operator?: {
        /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
        deploymentMode?: "operator" | "embedded";
        /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
        version?: string;
      };
      /** Configuration for the MeshSync agent on the managed cluster. */
      meshsync?: {
        /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
        version?: string;
        /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
        replicas?: number;
        /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
        watchList?: {
          /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
          whitelist?: {
            /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
            resource: string;
            /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
            events?: ("ADDED" | "MODIFIED" | "DELETED")[];
          }[];
          /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
          blacklist?: string[];
        };
        /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
        outputNamespaces?: string[];
        /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
        outputResources?: string[];
        /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
        redactSecrets?: boolean;
        /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
        brokerContentDedup?: boolean;
        /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
        debugLogging?: boolean;
      };
      /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
      broker?: {
        /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
        version?: string;
        /** Number of NATS server replicas (Broker custom resource spec.size). */
        replicas?: number;
        /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
        service?: {
          /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
          type?: "ClusterIP" | "NodePort" | "LoadBalancer";
          /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
          annotations?: {
            [key: string]: string;
          };
          /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
          loadBalancerClass?: string;
          /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
          loadBalancerSourceRanges?: string[];
          /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
          externalEndpointOverride?: string;
        };
      };
    };
    /** Deployment and runtime configuration for the Meshery controllers that manage a Kubernetes connection: Meshery Operator, MeshSync, and Meshery Broker. The same document shape is used at two layers. As a server-wide default it declares how Meshery Server deploys and configures the controllers for every managed cluster. As a per-connection override, stored in the connection's metadata, it overrides the server-wide default for a single connection. Every configuration field is optional: an absent field inherits the value from the next layer (per-connection override, then server-wide default, then built-in default). The only required field is the server-stamped schemaVersion discriminator, which identifies the document revision for future migrations. Learn more at https://docs.meshery.io/concepts/architecture */
    effective: {
      /** Specifies the version of the schema used for this configuration document. */
      schemaVersion: string;
      /** Configuration for the Meshery Operator on the managed cluster. */
      operator?: {
        /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
        deploymentMode?: "operator" | "embedded";
        /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
        version?: string;
      };
      /** Configuration for the MeshSync agent on the managed cluster. */
      meshsync?: {
        /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
        version?: string;
        /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
        replicas?: number;
        /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
        watchList?: {
          /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
          whitelist?: {
            /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
            resource: string;
            /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
            events?: ("ADDED" | "MODIFIED" | "DELETED")[];
          }[];
          /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
          blacklist?: string[];
        };
        /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
        outputNamespaces?: string[];
        /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
        outputResources?: string[];
        /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
        redactSecrets?: boolean;
        /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
        brokerContentDedup?: boolean;
        /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
        debugLogging?: boolean;
      };
      /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
      broker?: {
        /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
        version?: string;
        /** Number of NATS server replicas (Broker custom resource spec.size). */
        replicas?: number;
        /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
        service?: {
          /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
          type?: "ClusterIP" | "NodePort" | "LoadBalancer";
          /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
          annotations?: {
            [key: string]: string;
          };
          /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
          loadBalancerClass?: string;
          /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
          loadBalancerSourceRanges?: string[];
          /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
          externalEndpointOverride?: string;
        };
      };
    };
  };
export type UpdateConnectionControllersConfigApiArg = {
  /** Kubernetes connection ID. */
  connectionId: string;
  /** Controllers configuration document. Absent fields inherit from the next precedence layer. */
  body: {
    /** Configuration for the Meshery Operator on the managed cluster. */
    operator?: {
      /** How MeshSync is deployed for the connection. "operator" installs Meshery Operator into the cluster, which runs MeshSync and Meshery Broker there; "embedded" runs MeshSync in-process inside Meshery Server and installs nothing into the cluster. */
      deploymentMode?: "operator" | "embedded";
      /** Meshery Operator Helm chart version to deploy. When absent, the operator version tracks the Meshery Server release. */
      version?: string;
    };
    /** Configuration for the MeshSync agent on the managed cluster. */
    meshsync?: {
      /** MeshSync image tag to run (for example "v1.0.2" or "stable-latest"). Applies to operator deployment mode only; in embedded mode MeshSync runs at the version compiled into Meshery Server. Secret redaction and broker content deduplication require MeshSync v1.0.2 or newer. */
      version?: string;
      /** Number of MeshSync replicas (MeshSync custom resource spec.size). Applies to operator deployment mode only. */
      replicas?: number;
      /** Discovery scope for MeshSync, as a whitelist or a blacklist of Kubernetes resource types. */
      watchList?: {
        /** Resource types MeshSync watches, each with the event types to subscribe to. Mutually exclusive with blacklist. */
        whitelist?: {
          /** Resource key in "<plural>.<version>.<group>" form (for example "pods.v1." for core-group pods or "deployments.v1.apps"). */
          resource: string;
          /** Event types to subscribe to for this resource. Empty or absent subscribes to all event types. */
          events?: ("ADDED" | "MODIFIED" | "DELETED")[];
        }[];
        /** Resource types excluded from MeshSync's default discovery scope, in "<plural>.<version>.<group>" form (for example "pods.v1." or "deployments.v1.apps"). Mutually exclusive with whitelist. */
        blacklist?: string[];
      };
      /** Namespaces whose resources MeshSync publishes. Empty or absent publishes resources from all namespaces. Discovery scope is unaffected; this filters only what is published. */
      outputNamespaces?: string[];
      /** Resource types MeshSync publishes (lowercase Kubernetes kinds, for example "pod" or "deployment"). Empty or absent publishes all discovered resource types. Discovery scope is unaffected; this filters only what is published. */
      outputResources?: string[];
      /** When true, MeshSync redacts Kubernetes Secret data values (keys are preserved) before publishing. Requires MeshSync v1.0.2 or newer. Off by default; enabling is recommended when Secrets are within the discovery scope. */
      redactSecrets?: boolean;
      /** When true, MeshSync suppresses byte-identical republishes of a resource to the broker. Requires MeshSync v1.0.2 or newer. Off by default. */
      brokerContentDedup?: boolean;
      /** When true, MeshSync runs with debug-level logging (DEBUG environment variable). */
      debugLogging?: boolean;
    };
    /** Configuration for the Meshery Broker (NATS) on the managed cluster. */
    broker?: {
      /** NATS server image tag to run (Broker custom resource spec.version). When absent, the operator's bundled default NATS version is used. */
      version?: string;
      /** Number of NATS server replicas (Broker custom resource spec.size). */
      replicas?: number;
      /** How the broker is exposed on the network. Service changes reconcile in place without restarting broker pods. */
      service?: {
        /** Kubernetes Service type for client access. When absent the broker stays cluster-internal (ClusterIP). LoadBalancer acquires a cloud load-balancer address; NodePort exposes the broker on node IPs. */
        type?: "ClusterIP" | "NodePort" | "LoadBalancer";
        /** Annotations merged onto the client Service (cloud load-balancer hints, MetalLB address pools, internal-LB switches). */
        annotations?: {
          [key: string]: string;
        };
        /** Load-balancer implementation to use. Valid only when type is LoadBalancer. */
        loadBalancerClass?: string;
        /** CIDR ranges allowed to reach the broker. Valid only when type is LoadBalancer. */
        loadBalancerSourceRanges?: string[];
        /** Pins the advertised external broker endpoint as "host:port" when auto-derivation is undesirable: an ingress or gateway in front of the broker, an air-gapped topology, or NAT. The nats:// scheme is added by consumers. */
        externalEndpointOverride?: string;
      };
    };
  };
};
export type GetConsoleCapabilitiesApiResponse = /** status 200 The console kinds the target admits. */ {
  /** Whether an interactive terminal can be opened. */
  terminal: boolean;
  /** Whether a log stream can be opened. */
  logs: boolean;
  /** The addressable sub-targets, if the resource has any. */
  containers?: string[];
  /** The sub-target used when ConsoleTarget.container is empty. */
  defaultContainer?: string;
  /** Explains, for a human, why an unsupported console kind is unsupported — e.g. that the pod is not running. */
  reason?: string;
};
export type GetConsoleCapabilitiesApiArg = {
  /** The connection whose resources the console addresses. */
  connectionId: string;
  /** The driver-specific resource type, e.g. `pod` for a kubernetes connection. */
  resource: string;
  /** The resource's name within its scope. */
  name: string;
  /** The resource's parent scope, where it has one. Required for namespaced Kubernetes resources. */
  namespace?: string;
  /** A sub-target within the resource, e.g. a container within a pod. The driver's default sub-target is used when omitted. */
  container?: string;
};
export type OpenTerminalConsoleApiResponse = unknown;
export type OpenTerminalConsoleApiArg = {
  /** The connection whose resources the console addresses. */
  connectionId: string;
  /** The driver-specific resource type, e.g. `pod` for a kubernetes connection. */
  resource: string;
  /** The resource's name within its scope. */
  name: string;
  /** The resource's parent scope, where it has one. Required for namespaced Kubernetes resources. */
  namespace?: string;
  /** A sub-target within the resource, e.g. a container within a pod. The driver's default sub-target is used when omitted. */
  container?: string;
  /** The argv to execute, one query parameter per element. When omitted the driver picks a sensible interactive shell for the target. */
  command?: string[];
};
export type OpenLogConsoleApiResponse = unknown;
export type OpenLogConsoleApiArg = {
  /** The connection whose resources the console addresses. */
  connectionId: string;
  /** The driver-specific resource type, e.g. `pod` for a kubernetes connection. */
  resource: string;
  /** The resource's name within its scope. */
  name: string;
  /** The resource's parent scope, where it has one. Required for namespaced Kubernetes resources. */
  namespace?: string;
  /** A sub-target within the resource, e.g. a container within a pod. The driver's default sub-target is used when omitted. */
  container?: string;
  /** Keep the stream open and append new output as it is produced. */
  follow?: boolean;
  /** Return the logs of the target's prior instance, if any. */
  previous?: boolean;
  /** Prefix each line with an RFC 3339 timestamp. */
  timestamps?: boolean;
  /** Cap how many lines of history are replayed before following. Omit for no limit. */
  tailLines?: number;
  /** Bound history to output produced within the last N seconds. Omit for no bound; a value of 0 is treated as omitted. */
  sinceSeconds?: number;
};
export type EvaluateRelationshipsApiResponse = /** status 200 Successful evaluation */ {
  /** Specifies the version of the schema to which the evaluation response conforms. */
  schemaVersion: string;
  /** The final evaluated design, including all updated components and relationships. This can be either the complete updated design or only a diff of changes. The version of the design will be automatically incremented if any modifications are made during the evaluation process. This field provides a comprehensive view of the design state after all relationship evaluations and policy applications have been completed. */
  design: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    id: string;
    /** Name of the design; a descriptive, but concise title for the design document. */
    name: string;
    /** Specifies the version of the schema to which the design conforms. */
    schemaVersion: string;
    /** Revision of the design as expressed by an auto-incremented, SemVer-compliant version number. May be manually set by a user or third-party system, but will always be required to be of version number higher than the previously defined version number. */
    version: string;
    metadata?: {
      /** Map of resolved aliases present in the design */
      resolvedAliases?: {
        [key: string]: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          relationship_id: string;
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          alias_component_id: string;
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          immediate_parent_id: string;
          immediate_ref_field_path: string[];
        } & {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          resolved_parent_id: string;
          resolved_ref_field_path: string[];
        };
      };
      [key: string]: any;
    };
    /** A list of one or more component declarations. */
    components: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** Specifies the version of the schema to which the component definition conforms. */
      schemaVersion: string;
      /** Version of the component definition. */
      version: string;
      /** Name of the component in human-readible format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the component. */
      description: string;
      /** Format specifies the format used in the `component.schema` field. JSON is the default. */
      format: "JSON" | "CUE";
      /** 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 */
      model: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
        /** Version of the model definition. */
        version: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Description of the model. */
        description: string;
        /** Status of model, including:
                - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
                - maintenance: model is unavailable for a period of time.
                - enabled: model is available for use for all users of this Meshery Server.
                - ignored: model is unavailable for use for all users of this Meshery Server. */
        status: "ignored" | "enabled" | "duplicate";
        /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
        registrant: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** Connection Name */
          name: string;
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          credentialId?: string;
          /** Connection Type (platform, telemetry, collaboration) */
          type: string;
          /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
          subType: string;
          /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
          kind: string;
          /** Additional connection metadata */
          metadata?: object;
          /** Connection Status */
          status:
            | "discovered"
            | "registered"
            | "connected"
            | "ignored"
            | "maintenance"
            | "disconnected"
            | "deleted"
            | "not found";
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          user_id?: string;
          created_at?: string;
          updated_at?: string;
          /** SQL null Timestamp to handle null values of time. */
          deleted_at?: string;
          /** Associated environments for this connection */
          environments?: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id: string;
            /** Specifies the version of the schema to which the environment conforms. */
            schemaVersion: string;
            /** Environment name */
            name: string;
            /** Environment description */
            description: string;
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            organization_id: string;
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            owner?: string;
            /** Timestamp when the resource was created. */
            created_at?: string;
            /** Additional metadata associated with the environment. */
            metadata?: object;
            /** Timestamp when the resource was updated. */
            updated_at?: string;
            /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
            deleted_at?: string | null;
          }[];
          /** Specifies the version of the schema used for the definition. */
          schemaVersion: string;
        };
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        registrantId: string;
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        categoryId: string;
        /** Category of the model. */
        category: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The category of the model that determines the main grouping. */
          name:
            | "Analytics"
            | "App Definition and Development"
            | "Cloud Native Network"
            | "Cloud Native Storage"
            | "Database"
            | "Machine Learning"
            | "Observability and Analysis"
            | "Orchestration & Management"
            | "Platform"
            | "Provisioning"
            | "Runtime"
            | "Security & Compliance"
            | "Serverless"
            | "Tools"
            | "Uncategorized";
          /** Additional metadata associated with the category. */
          metadata: object;
        };
        /** Sub category of the model determines the secondary grouping. */
        subCategory:
          | "API Gateway"
          | "API Integration"
          | "Application Definition & Image Build"
          | "Automation & Configuration"
          | "Certified Kubernetes - Distribution"
          | "Chaos Engineering"
          | "Cloud Native Storage"
          | "Cloud Provider"
          | "CNI"
          | "Compute"
          | "Container Registry"
          | "Container Runtime"
          | "Container Security"
          | "Container"
          | "Content Delivery Network"
          | "Continuous Integration & Delivery"
          | "Coordination & Service Discovery"
          | "Database"
          | "Flowchart"
          | "Framework"
          | "Installable Platform"
          | "Key Management"
          | "Key Management Service"
          | "Kubernetes"
          | "Logging"
          | "Machine Learning"
          | "Management Governance"
          | "Metrics"
          | "Monitoring"
          | "Networking Content Delivery"
          | "Operating System"
          | "Query"
          | "Remote Procedure Call"
          | "Scheduling & Orchestration"
          | "Secrets Management"
          | "Security Identity & Compliance"
          | "Service Mesh"
          | "Service Proxy"
          | "Source Version Control"
          | "Storage"
          | "Specifications"
          | "Streaming & Messaging"
          | "Tools"
          | "Tracing"
          | "Uncategorized"
          | "Video Conferencing";
        /** Metadata containing additional information associated with the model. */
        metadata?: {
          /** Capabilities associated with the model */
          capabilities?: {
            /** Specifies the version of the schema to which the capability definition conforms. */
            schemaVersion: string;
            /** Version of the capability definition. */
            version: string;
            /** Name of the capability in human-readible format. */
            displayName: string;
            /** A written representation of the purpose and characteristics of the capability. */
            description: string;
            /** Top-level categorization of the capability */
            kind: "action" | "mutate" | "view" | "interaction";
            /** Classification of capabilities. Used to group capabilities similar in nature. */
            type: string;
            /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
            subType: string;
            /** Key that backs the capability. */
            key: string;
            /** State of the entity in which the capability is applicable. */
            entityState: ("declaration" | "instance")[];
            /** Status of the capability */
            status: "enabled" | "disabled";
            /** Metadata contains additional information associated with the capability. Extension point. */
            metadata?: {
              [key: string]: any;
            };
          }[];
          /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
          isAnnotation?: boolean;
          /** Primary color associated with the model. */
          primaryColor?: string;
          /** Secondary color associated with the model. */
          secondaryColor?: string;
          /** SVG representation of the model in white color. */
          svgWhite: string;
          /** SVG representation of the model in colored format. */
          svgColor: string;
          /** SVG representation of the complete model. */
          svgComplete?: string;
          /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
          shape?:
            | "ellipse"
            | "triangle"
            | "round-triangle"
            | "rectangle"
            | "round-rectangle"
            | "bottom-round-rectangle"
            | "cut-rectangle"
            | "barrel"
            | "rhomboid"
            | "diamond"
            | "round-diamond"
            | "pentagon"
            | "round-pentagon"
            | "hexagon"
            | "round-hexagon"
            | "concave-hexagon"
            | "heptagon"
            | "round-heptagon"
            | "octagon"
            | "round-octagon"
            | "star"
            | "tag"
            | "round-tag"
            | "vee"
            | "polygon";
          [key: string]: any;
        };
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        /** The relationships of the model. */
        relationships: any;
        /** The components of the model. */
        components: any;
        /** Number of components associated with the model. */
        componentsCount: number;
        /** Number of relationships associated with the model. */
        relationshipsCount: number;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
      };
      /** 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 */
      modelReference: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      modelId?: string;
      /** Visualization styles for a component */
      styles?: {
        /** Primary color of the component used for UI representation. */
        primaryColor: string;
        /** Secondary color of the entity used for UI representation. */
        secondaryColor?: string;
        /** White SVG of the entity used for UI representation on dark background. */
        svgWhite: string;
        /** Colored SVG of the entity used for UI representation on light background. */
        svgColor: string;
        /** Complete SVG of the entity used for UI representation, often inclusive of background. */
        svgComplete: string;
        /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
        color?: string;
        /** The opacity of the label text, including its outline. */
        "text-opacity"?: number;
        /** A comma-separated list of font names to use on the label text. */
        "font-family"?: string;
        /** The size of the label text. */
        "font-size"?: string;
        /** A CSS font style to be applied to the label text. */
        "font-style"?: string;
        /** A CSS font weight to be applied to the label text. */
        "font-weight"?: string;
        /** A transformation to apply to the label text */
        "text-transform"?: "none" | "uppercase" | "lowercase";
        /** 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. */
        opacity?: number;
        /** 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. */
        "z-index"?: number;
        /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
        label?: string;
        /** The animation to apply to the element. example ripple,bounce,etc */
        animation?: object;
        [key: string]: any;
      } & {
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
        position?: {
          /** The x-coordinate of the node. */
          x: number;
          /** The y-coordinate of the node. */
          y: number;
        };
        /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
        "body-text"?: string;
        /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
        "body-text-wrap"?: string;
        /** The maximum width for wrapping text in the node. */
        "body-text-max-width"?: string;
        /** The opacity of the node's body text, including its outline. */
        "body-text-opacity"?: number;
        /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
        "body-text-background-color"?: string;
        /** The size of the node's body text. */
        "body-text-font-size"?: number;
        /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
        "body-text-color"?: string;
        /** A CSS font weight to be applied to the node's body text. */
        "body-text-font-weight"?: string;
        /** A CSS horizontal alignment to be applied to the node's body text. */
        "body-text-horizontal-align"?: string;
        /** A CSS text decoration to be applied to the node's body text. */
        "body-text-decoration"?: string;
        /** A CSS vertical alignment to be applied to the node's body text. */
        "body-text-vertical-align"?: string;
        /** The width of the node's body or the width of an edge's line. */
        width?: number;
        /** The height of the node's body */
        height?: number;
        /** The URL that points to the image to show in the node. */
        "background-image"?: string;
        /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
        "background-color"?: string;
        /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
        "background-blacken"?: number;
        /** The opacity level of the node's background colour */
        "background-opacity"?: number;
        /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        "background-position-x"?: string;
        /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        "background-position-y"?: string;
        /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        "background-offset-x"?: string;
        /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        "background-offset-y"?: string;
        /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
        "background-fit"?: string;
        /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
        "background-clip"?: string;
        /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
        "background-width-relative-to"?: string;
        /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
        "background-height-relative-to"?: string;
        /** The size of the node's border. */
        "border-width"?: number;
        /** The style of the node's border */
        "border-style"?: "solid" | "dotted" | "dashed" | "double";
        /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
        "border-color"?: string;
        /** The opacity of the node's border */
        "border-opacity"?: number;
        /** The amount of padding around all sides of the node. */
        padding?: number;
        /** The horizontal alignment of a node's label */
        "text-halign"?: "left" | "center" | "right";
        /** The vertical alignment of a node's label */
        "text-valign"?: "top" | "center" | "bottom";
        /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
        ghost?: "yes" | "no";
        /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        "active-bg-color"?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        "active-bg-opacity"?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        "active-bg-size"?: string;
        /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        "selection-box-color"?: string;
        /** The size of the border on the selection box. Selector needs to be *core* */
        "selection-box-border-width"?: number;
        /** The opacity of the selection box. Selector needs to be *core* */
        "selection-box-opacity"?: number;
        /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        "outside-texture-bg-color"?: string;
        /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
        "outside-texture-bg-opacity"?: number;
        /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
        "shape-polygon-points"?: string;
        /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        "menu-background-color"?: string;
        /** The opacity of the background of the component menu. */
        "menu-background-opacity"?: number;
        /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        "menu-forground-color"?: string;
      };
      /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Status of component, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
      status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
      /** Metadata contains additional information associated with the component. */
      metadata: {
        /** Genealogy represents the various representational states of the component. */
        genealogy: string;
        /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
        isAnnotation: boolean;
        /** Identifies whether the component is scoped to namespace or clsuter wide. */
        isNamespaced: boolean;
        /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
        published: boolean;
        /** InstanceDetails contains information about the instance of the component. */
        instanceDetails: object;
        /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
        configurationUISchema: string;
        [key: string]: any;
      };
      /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
      configuration: object;
      /** data related to the third party capability that Component Defintion wraps , this is herematicaly sealed an */
      component: {
        /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
        version: string;
        /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
        kind: string;
        /** JSON schema of the object as defined by the registrant. */
        schema: string;
      };
      /** Timestamp when the resource was created. */
      created_at?: string;
      /** Timestamp when the resource was updated. */
      updated_at?: string;
    }[];
    /** Design-level preferences */
    preferences?: {
      /** Map of available layers, where keys are layer names. */
      layers: object;
    };
    /** List of relationships between components */
    relationships: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** Specifies the version of the schema used for the relationship definition. */
      schemaVersion: string;
      /** Specifies the version of the relationship definition. */
      version: string;
      /** Kind of the Relationship. Learn more about relationships - https://docs.meshery.io/concepts/logical/relationships. */
      kind: "hierarchical" | "edge" | "sibling";
      /** Classification of relationships. Used to group relationships similar in nature. */
      type: string;
      /** Most granular unit of relationship classification. The combination of Kind, Type and SubType together uniquely identify a Relationship. */
      subType: string;
      /** Status of the relationship. */
      status?: "enabled" | "ignored" | "deleted" | "approved" | "pending";
      /** Capabilities associated with the relationship. */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Metadata contains additional information associated with the Relationship. */
      metadata?: {
        /** Characterization of the meaning of the relationship and its relevance to both Meshery and entities under management. */
        description?: string;
        /** Visualization styles for a relationship */
        styles?: {
          /** Primary color of the component used for UI representation. */
          primaryColor: string;
          /** Secondary color of the entity used for UI representation. */
          secondaryColor?: string;
          /** White SVG of the entity used for UI representation on dark background. */
          svgWhite: string;
          /** Colored SVG of the entity used for UI representation on light background. */
          svgColor: string;
          /** Complete SVG of the entity used for UI representation, often inclusive of background. */
          svgComplete?: string;
          /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
          color?: string;
          /** The opacity of the label text, including its outline. */
          "text-opacity"?: number;
          /** A comma-separated list of font names to use on the label text. */
          "font-family"?: string;
          /** The size of the label text. */
          "font-size"?: string;
          /** A CSS font style to be applied to the label text. */
          "font-style"?: string;
          /** A CSS font weight to be applied to the label text. */
          "font-weight"?: string;
          /** A transformation to apply to the label text */
          "text-transform"?: "none" | "uppercase" | "lowercase";
          /** 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 */
          opacity?: number;
          /** 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. */
          "z-index"?: number;
          /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
          label?: string;
          /** The animation to use for the edge. Can be like 'marching-ants' , 'blink' , 'moving-gradient',etc . */
          "edge-animation"?: string;
          /** 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. */
          "curve-style"?: "haystack" | "straight" | "bezier" | "unbundled-bezier" | "segments" | "taxi";
          /** The colour of the edge's line. Colours may be specified by name (e.g. red), hex (e.g. */
          "line-color"?: string;
          /** The style of the edge's line. */
          "line-style"?: "solid" | "dotted" | "dashed";
          /** 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. */
          "line-cap"?: "butt" | "round" | "square";
          /** 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. */
          "line-opacity"?: number;
          /** The colour of the edge's source arrow. Colours may be specified by name (e.g. red), hex (e.g. */
          "target-arrow-color"?: string;
          /** The shape of the edge's source arrow */
          "target-arrow-shape"?:
            | "triangle"
            | "triangle-tee"
            | "circle-triangle"
            | "triangle-cross"
            | "triangle-backcurve"
            | "vee"
            | "tee"
            | "square"
            | "circle"
            | "diamond"
            | "chevron"
            | "none";
          /** The fill state of the edge's source arrow */
          "target-arrow-fill"?: "filled" | "hollow";
          /** The colour of the edge's source arrow. Colours may be specified by name (e.g. red), hex (e.g. */
          "mid-target-arrow-color"?: string;
          /** The shape of the edge's source arrow */
          "mid-target-arrow-shape"?:
            | "triangle"
            | "triangle-tee"
            | "circle-triangle"
            | "triangle-cross"
            | "triangle-backcurve"
            | "vee"
            | "tee"
            | "square"
            | "circle"
            | "diamond"
            | "chevron"
            | "none";
          /** The fill state of the edge's source arrow */
          "mid-target-arrow-fill"?: "filled" | "hollow";
          /** Scaling for the arrow size. */
          "arrow-scale"?: number;
          /** The text to display for an edge's source label. Can give a path, e.g. data(id) will label with the elements id */
          "source-label"?: string;
          /** The text to display for an edge's target label. Can give a path, e.g. data(id) will label with the elements id */
          "target-label"?: string;
        };
        /** Indicates whether the relationship should be treated as a logical representation only */
        isAnnotation?: boolean;
        [key: string]: any;
      };
      /** Model 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 */
      model: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      modelId?: string;
      /** 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. */
      evaluationQuery?: string;
      /** 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. */
      selectors?: {
        /** Selectors used to define relationships which are allowed. */
        allow: {
          /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
          from: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id?: string;
            kind?: string;
            /** Match configuration for selector */
            match?: {
              refs?: string[][];
              from?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id?: string;
                kind: string;
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              }[];
              to?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id?: string;
                kind: string;
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              }[];
            };
            /** Match strategy matrix for the selector */
            match_strategy_matrix?: string[][];
            /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
            model?: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id: string;
              /** The unique name for the model within the scope of a registrant. */
              name: string;
              /** Version of the model definition. */
              version: string;
              /** Human-readable name for the model. */
              displayName: string;
              /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
              model: {
                /** Version of the model as defined by the registrant. */
                version: string;
              };
              registrant: {
                /** Kind of the registrant. */
                kind: string;
              };
            };
            /** Patch configuration for the selector */
            patch?: {
              /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                            
                            add: Inserts a value into an array or adds a member to an object.
                            replace: Replaces a value.
                            merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                            strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                            remove: Removes a value.
                            copy: Copies a value from one location to another.
                            move: Moves a value from one location to another.
                            test: Tests that a value at the target location is equal to a specified value.
                             */
              patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
              /** JSON ref to value from where patch should be applied. */
              mutatorRef?: string[][];
              mutatedRef?: string[][];
            };
          }[];
          /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
          to: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id?: string;
            kind?: string;
            /** Match configuration for selector */
            match?: {
              refs?: string[][];
              from?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id?: string;
                kind: string;
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              }[];
              to?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id?: string;
                kind: string;
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              }[];
            };
            /** Match strategy matrix for the selector */
            match_strategy_matrix?: string[][];
            /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
            model?: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id: string;
              /** The unique name for the model within the scope of a registrant. */
              name: string;
              /** Version of the model definition. */
              version: string;
              /** Human-readable name for the model. */
              displayName: string;
              /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
              model: {
                /** Version of the model as defined by the registrant. */
                version: string;
              };
              registrant: {
                /** Kind of the registrant. */
                kind: string;
              };
            };
            /** Patch configuration for the selector */
            patch?: {
              /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                            
                            add: Inserts a value into an array or adds a member to an object.
                            replace: Replaces a value.
                            merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                            strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                            remove: Removes a value.
                            copy: Copies a value from one location to another.
                            move: Moves a value from one location to another.
                            test: Tests that a value at the target location is equal to a specified value.
                             */
              patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
              /** JSON ref to value from where patch should be applied. */
              mutatorRef?: string[][];
              mutatedRef?: string[][];
            };
          }[];
        };
        /** Optional selectors used to define relationships which should not be created / is restricted. */
        deny?: {
          /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
          from: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id?: string;
            kind?: string;
            /** Match configuration for selector */
            match?: {
              refs?: string[][];
              from?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id?: string;
                kind: string;
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              }[];
              to?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id?: string;
                kind: string;
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              }[];
            };
            /** Match strategy matrix for the selector */
            match_strategy_matrix?: string[][];
            /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
            model?: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id: string;
              /** The unique name for the model within the scope of a registrant. */
              name: string;
              /** Version of the model definition. */
              version: string;
              /** Human-readable name for the model. */
              displayName: string;
              /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
              model: {
                /** Version of the model as defined by the registrant. */
                version: string;
              };
              registrant: {
                /** Kind of the registrant. */
                kind: string;
              };
            };
            /** Patch configuration for the selector */
            patch?: {
              /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                            
                            add: Inserts a value into an array or adds a member to an object.
                            replace: Replaces a value.
                            merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                            strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                            remove: Removes a value.
                            copy: Copies a value from one location to another.
                            move: Moves a value from one location to another.
                            test: Tests that a value at the target location is equal to a specified value.
                             */
              patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
              /** JSON ref to value from where patch should be applied. */
              mutatorRef?: string[][];
              mutatedRef?: string[][];
            };
          }[];
          /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
          to: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id?: string;
            kind?: string;
            /** Match configuration for selector */
            match?: {
              refs?: string[][];
              from?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id?: string;
                kind: string;
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              }[];
              to?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id?: string;
                kind: string;
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              }[];
            };
            /** Match strategy matrix for the selector */
            match_strategy_matrix?: string[][];
            /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
            model?: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id: string;
              /** The unique name for the model within the scope of a registrant. */
              name: string;
              /** Version of the model definition. */
              version: string;
              /** Human-readable name for the model. */
              displayName: string;
              /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
              model: {
                /** Version of the model as defined by the registrant. */
                version: string;
              };
              registrant: {
                /** Kind of the registrant. */
                kind: string;
              };
            };
            /** Patch configuration for the selector */
            patch?: {
              /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                            
                            add: Inserts a value into an array or adds a member to an object.
                            replace: Replaces a value.
                            merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                            strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                            remove: Removes a value.
                            copy: Copies a value from one location to another.
                            move: Moves a value from one location to another.
                            test: Tests that a value at the target location is equal to a specified value.
                             */
              patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
              /** JSON ref to value from where patch should be applied. */
              mutatorRef?: string[][];
              mutatedRef?: string[][];
            };
          }[];
        };
      }[];
    }[];
  };
  /** Hash of the input parameters and configuration used for this evaluation. Useful for identifying duplicate evaluations or caching results. */
  evaluationHash?: string;
  /** ISO 8601 formatted timestamp of when the evaluation was completed. */
  timestamp?: string;
  /** The actions of the evaluationresponse. */
  actions: {
    /** The op of the action. */
    op:
      | "update_component"
      | "update_component_configuration"
      | "add_component"
      | "delete_component"
      | "add_relationship"
      | "update_relationship"
      | "delete_relationship";
    /** The value of the action. */
    value: object;
  }[];
};
export type EvaluateRelationshipsApiArg = {
  body: {
    /** Designs are your primary tool for collaborative authorship of your infrastructure, workflow, and processes. */
    design: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** Name of the design; a descriptive, but concise title for the design document. */
      name: string;
      /** Specifies the version of the schema to which the design conforms. */
      schemaVersion: string;
      /** Revision of the design as expressed by an auto-incremented, SemVer-compliant version number. May be manually set by a user or third-party system, but will always be required to be of version number higher than the previously defined version number. */
      version: string;
      metadata?: {
        /** Map of resolved aliases present in the design */
        resolvedAliases?: {
          [key: string]: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            relationship_id: string;
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            alias_component_id: string;
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            immediate_parent_id: string;
            immediate_ref_field_path: string[];
          } & {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            resolved_parent_id: string;
            resolved_ref_field_path: string[];
          };
        };
        [key: string]: any;
      };
      /** A list of one or more component declarations. */
      components: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** Specifies the version of the schema to which the component definition conforms. */
        schemaVersion: string;
        /** Version of the component definition. */
        version: string;
        /** Name of the component in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the component. */
        description: string;
        /** Format specifies the format used in the `component.schema` field. JSON is the default. */
        format: "JSON" | "CUE";
        /** 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 */
        model: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** Specifies the version of the schema used for the definition. */
          schemaVersion: string;
          /** Version of the model definition. */
          version: string;
          /** The unique name for the model within the scope of a registrant. */
          name: string;
          /** Human-readable name for the model. */
          displayName: string;
          /** Description of the model. */
          description: string;
          /** Status of model, including:
                    - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
                    - maintenance: model is unavailable for a period of time.
                    - enabled: model is available for use for all users of this Meshery Server.
                    - ignored: model is unavailable for use for all users of this Meshery Server. */
          status: "ignored" | "enabled" | "duplicate";
          /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
          registrant: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id: string;
            /** Connection Name */
            name: string;
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            credentialId?: string;
            /** Connection Type (platform, telemetry, collaboration) */
            type: string;
            /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
            subType: string;
            /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
            kind: string;
            /** Additional connection metadata */
            metadata?: object;
            /** Connection Status */
            status:
              | "discovered"
              | "registered"
              | "connected"
              | "ignored"
              | "maintenance"
              | "disconnected"
              | "deleted"
              | "not found";
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            user_id?: string;
            created_at?: string;
            updated_at?: string;
            /** SQL null Timestamp to handle null values of time. */
            deleted_at?: string;
            /** Associated environments for this connection */
            environments?: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id: string;
              /** Specifies the version of the schema to which the environment conforms. */
              schemaVersion: string;
              /** Environment name */
              name: string;
              /** Environment description */
              description: string;
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              organization_id: string;
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              owner?: string;
              /** Timestamp when the resource was created. */
              created_at?: string;
              /** Additional metadata associated with the environment. */
              metadata?: object;
              /** Timestamp when the resource was updated. */
              updated_at?: string;
              /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
              deleted_at?: string | null;
            }[];
            /** Specifies the version of the schema used for the definition. */
            schemaVersion: string;
          };
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          registrantId: string;
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          categoryId: string;
          /** Category of the model. */
          category: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id: string;
            /** The category of the model that determines the main grouping. */
            name:
              | "Analytics"
              | "App Definition and Development"
              | "Cloud Native Network"
              | "Cloud Native Storage"
              | "Database"
              | "Machine Learning"
              | "Observability and Analysis"
              | "Orchestration & Management"
              | "Platform"
              | "Provisioning"
              | "Runtime"
              | "Security & Compliance"
              | "Serverless"
              | "Tools"
              | "Uncategorized";
            /** Additional metadata associated with the category. */
            metadata: object;
          };
          /** Sub category of the model determines the secondary grouping. */
          subCategory:
            | "API Gateway"
            | "API Integration"
            | "Application Definition & Image Build"
            | "Automation & Configuration"
            | "Certified Kubernetes - Distribution"
            | "Chaos Engineering"
            | "Cloud Native Storage"
            | "Cloud Provider"
            | "CNI"
            | "Compute"
            | "Container Registry"
            | "Container Runtime"
            | "Container Security"
            | "Container"
            | "Content Delivery Network"
            | "Continuous Integration & Delivery"
            | "Coordination & Service Discovery"
            | "Database"
            | "Flowchart"
            | "Framework"
            | "Installable Platform"
            | "Key Management"
            | "Key Management Service"
            | "Kubernetes"
            | "Logging"
            | "Machine Learning"
            | "Management Governance"
            | "Metrics"
            | "Monitoring"
            | "Networking Content Delivery"
            | "Operating System"
            | "Query"
            | "Remote Procedure Call"
            | "Scheduling & Orchestration"
            | "Secrets Management"
            | "Security Identity & Compliance"
            | "Service Mesh"
            | "Service Proxy"
            | "Source Version Control"
            | "Storage"
            | "Specifications"
            | "Streaming & Messaging"
            | "Tools"
            | "Tracing"
            | "Uncategorized"
            | "Video Conferencing";
          /** Metadata containing additional information associated with the model. */
          metadata?: {
            /** Capabilities associated with the model */
            capabilities?: {
              /** Specifies the version of the schema to which the capability definition conforms. */
              schemaVersion: string;
              /** Version of the capability definition. */
              version: string;
              /** Name of the capability in human-readible format. */
              displayName: string;
              /** A written representation of the purpose and characteristics of the capability. */
              description: string;
              /** Top-level categorization of the capability */
              kind: "action" | "mutate" | "view" | "interaction";
              /** Classification of capabilities. Used to group capabilities similar in nature. */
              type: string;
              /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
              subType: string;
              /** Key that backs the capability. */
              key: string;
              /** State of the entity in which the capability is applicable. */
              entityState: ("declaration" | "instance")[];
              /** Status of the capability */
              status: "enabled" | "disabled";
              /** Metadata contains additional information associated with the capability. Extension point. */
              metadata?: {
                [key: string]: any;
              };
            }[];
            /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
            isAnnotation?: boolean;
            /** Primary color associated with the model. */
            primaryColor?: string;
            /** Secondary color associated with the model. */
            secondaryColor?: string;
            /** SVG representation of the model in white color. */
            svgWhite: string;
            /** SVG representation of the model in colored format. */
            svgColor: string;
            /** SVG representation of the complete model. */
            svgComplete?: string;
            /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
            shape?:
              | "ellipse"
              | "triangle"
              | "round-triangle"
              | "rectangle"
              | "round-rectangle"
              | "bottom-round-rectangle"
              | "cut-rectangle"
              | "barrel"
              | "rhomboid"
              | "diamond"
              | "round-diamond"
              | "pentagon"
              | "round-pentagon"
              | "hexagon"
              | "round-hexagon"
              | "concave-hexagon"
              | "heptagon"
              | "round-heptagon"
              | "octagon"
              | "round-octagon"
              | "star"
              | "tag"
              | "round-tag"
              | "vee"
              | "polygon";
            [key: string]: any;
          };
          /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
          model: {
            /** Version of the model as defined by the registrant. */
            version: string;
          };
          /** The relationships of the model. */
          relationships: any;
          /** The components of the model. */
          components: any;
          /** Number of components associated with the model. */
          componentsCount: number;
          /** Number of relationships associated with the model. */
          relationshipsCount: number;
          /** Timestamp when the resource was created. */
          created_at?: string;
          /** Timestamp when the resource was updated. */
          updated_at?: string;
        };
        /** 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 */
        modelReference: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The unique name for the model within the scope of a registrant. */
          name: string;
          /** Version of the model definition. */
          version: string;
          /** Human-readable name for the model. */
          displayName: string;
          /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
          model: {
            /** Version of the model as defined by the registrant. */
            version: string;
          };
          registrant: {
            /** Kind of the registrant. */
            kind: string;
          };
        };
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        modelId?: string;
        /** Visualization styles for a component */
        styles?: {
          /** Primary color of the component used for UI representation. */
          primaryColor: string;
          /** Secondary color of the entity used for UI representation. */
          secondaryColor?: string;
          /** White SVG of the entity used for UI representation on dark background. */
          svgWhite: string;
          /** Colored SVG of the entity used for UI representation on light background. */
          svgColor: string;
          /** Complete SVG of the entity used for UI representation, often inclusive of background. */
          svgComplete: string;
          /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
          color?: string;
          /** The opacity of the label text, including its outline. */
          "text-opacity"?: number;
          /** A comma-separated list of font names to use on the label text. */
          "font-family"?: string;
          /** The size of the label text. */
          "font-size"?: string;
          /** A CSS font style to be applied to the label text. */
          "font-style"?: string;
          /** A CSS font weight to be applied to the label text. */
          "font-weight"?: string;
          /** A transformation to apply to the label text */
          "text-transform"?: "none" | "uppercase" | "lowercase";
          /** 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. */
          opacity?: number;
          /** 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. */
          "z-index"?: number;
          /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
          label?: string;
          /** The animation to apply to the element. example ripple,bounce,etc */
          animation?: object;
          [key: string]: any;
        } & {
          /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
          shape:
            | "ellipse"
            | "triangle"
            | "round-triangle"
            | "rectangle"
            | "round-rectangle"
            | "bottom-round-rectangle"
            | "cut-rectangle"
            | "barrel"
            | "rhomboid"
            | "diamond"
            | "round-diamond"
            | "pentagon"
            | "round-pentagon"
            | "hexagon"
            | "round-hexagon"
            | "concave-hexagon"
            | "heptagon"
            | "round-heptagon"
            | "octagon"
            | "round-octagon"
            | "star"
            | "tag"
            | "round-tag"
            | "vee"
            | "polygon";
          /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
          position?: {
            /** The x-coordinate of the node. */
            x: number;
            /** The y-coordinate of the node. */
            y: number;
          };
          /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
          "body-text"?: string;
          /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
          "body-text-wrap"?: string;
          /** The maximum width for wrapping text in the node. */
          "body-text-max-width"?: string;
          /** The opacity of the node's body text, including its outline. */
          "body-text-opacity"?: number;
          /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
          "body-text-background-color"?: string;
          /** The size of the node's body text. */
          "body-text-font-size"?: number;
          /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
          "body-text-color"?: string;
          /** A CSS font weight to be applied to the node's body text. */
          "body-text-font-weight"?: string;
          /** A CSS horizontal alignment to be applied to the node's body text. */
          "body-text-horizontal-align"?: string;
          /** A CSS text decoration to be applied to the node's body text. */
          "body-text-decoration"?: string;
          /** A CSS vertical alignment to be applied to the node's body text. */
          "body-text-vertical-align"?: string;
          /** The width of the node's body or the width of an edge's line. */
          width?: number;
          /** The height of the node's body */
          height?: number;
          /** The URL that points to the image to show in the node. */
          "background-image"?: string;
          /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
          "background-color"?: string;
          /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
          "background-blacken"?: number;
          /** The opacity level of the node's background colour */
          "background-opacity"?: number;
          /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
          "background-position-x"?: string;
          /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
          "background-position-y"?: string;
          /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
          "background-offset-x"?: string;
          /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
          "background-offset-y"?: string;
          /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
          "background-fit"?: string;
          /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
          "background-clip"?: string;
          /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
          "background-width-relative-to"?: string;
          /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
          "background-height-relative-to"?: string;
          /** The size of the node's border. */
          "border-width"?: number;
          /** The style of the node's border */
          "border-style"?: "solid" | "dotted" | "dashed" | "double";
          /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
          "border-color"?: string;
          /** The opacity of the node's border */
          "border-opacity"?: number;
          /** The amount of padding around all sides of the node. */
          padding?: number;
          /** The horizontal alignment of a node's label */
          "text-halign"?: "left" | "center" | "right";
          /** The vertical alignment of a node's label */
          "text-valign"?: "top" | "center" | "bottom";
          /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
          ghost?: "yes" | "no";
          /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
          "active-bg-color"?: string;
          /** The opacity of the active background indicator. Selector needs to be *core*. */
          "active-bg-opacity"?: string;
          /** The opacity of the active background indicator. Selector needs to be *core*. */
          "active-bg-size"?: string;
          /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
          "selection-box-color"?: string;
          /** The size of the border on the selection box. Selector needs to be *core* */
          "selection-box-border-width"?: number;
          /** The opacity of the selection box. Selector needs to be *core* */
          "selection-box-opacity"?: number;
          /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
          "outside-texture-bg-color"?: string;
          /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
          "outside-texture-bg-opacity"?: number;
          /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
          "shape-polygon-points"?: string;
          /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
          "menu-background-color"?: string;
          /** The opacity of the background of the component menu. */
          "menu-background-opacity"?: number;
          /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
          "menu-forground-color"?: string;
        };
        /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Status of component, including:
                - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
                - maintenance: model is unavailable for a period of time.
                - enabled: model is available for use for all users of this Meshery Server.
                - ignored: model is unavailable for use for all users of this Meshery Server. */
        status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
        /** Metadata contains additional information associated with the component. */
        metadata: {
          /** Genealogy represents the various representational states of the component. */
          genealogy: string;
          /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
          isAnnotation: boolean;
          /** Identifies whether the component is scoped to namespace or clsuter wide. */
          isNamespaced: boolean;
          /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
          published: boolean;
          /** InstanceDetails contains information about the instance of the component. */
          instanceDetails: object;
          /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
          configurationUISchema: string;
          [key: string]: any;
        };
        /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
        configuration: object;
        /** data related to the third party capability that Component Defintion wraps , this is herematicaly sealed an */
        component: {
          /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
          version: string;
          /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
          kind: string;
          /** JSON schema of the object as defined by the registrant. */
          schema: string;
        };
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
      }[];
      /** Design-level preferences */
      preferences?: {
        /** Map of available layers, where keys are layer names. */
        layers: object;
      };
      /** List of relationships between components */
      relationships: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** Specifies the version of the schema used for the relationship definition. */
        schemaVersion: string;
        /** Specifies the version of the relationship definition. */
        version: string;
        /** Kind of the Relationship. Learn more about relationships - https://docs.meshery.io/concepts/logical/relationships. */
        kind: "hierarchical" | "edge" | "sibling";
        /** Classification of relationships. Used to group relationships similar in nature. */
        type: string;
        /** Most granular unit of relationship classification. The combination of Kind, Type and SubType together uniquely identify a Relationship. */
        subType: string;
        /** Status of the relationship. */
        status?: "enabled" | "ignored" | "deleted" | "approved" | "pending";
        /** Capabilities associated with the relationship. */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Metadata contains additional information associated with the Relationship. */
        metadata?: {
          /** Characterization of the meaning of the relationship and its relevance to both Meshery and entities under management. */
          description?: string;
          /** Visualization styles for a relationship */
          styles?: {
            /** Primary color of the component used for UI representation. */
            primaryColor: string;
            /** Secondary color of the entity used for UI representation. */
            secondaryColor?: string;
            /** White SVG of the entity used for UI representation on dark background. */
            svgWhite: string;
            /** Colored SVG of the entity used for UI representation on light background. */
            svgColor: string;
            /** Complete SVG of the entity used for UI representation, often inclusive of background. */
            svgComplete?: string;
            /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
            color?: string;
            /** The opacity of the label text, including its outline. */
            "text-opacity"?: number;
            /** A comma-separated list of font names to use on the label text. */
            "font-family"?: string;
            /** The size of the label text. */
            "font-size"?: string;
            /** A CSS font style to be applied to the label text. */
            "font-style"?: string;
            /** A CSS font weight to be applied to the label text. */
            "font-weight"?: string;
            /** A transformation to apply to the label text */
            "text-transform"?: "none" | "uppercase" | "lowercase";
            /** 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 */
            opacity?: number;
            /** 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. */
            "z-index"?: number;
            /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
            label?: string;
            /** The animation to use for the edge. Can be like 'marching-ants' , 'blink' , 'moving-gradient',etc . */
            "edge-animation"?: string;
            /** 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. */
            "curve-style"?: "haystack" | "straight" | "bezier" | "unbundled-bezier" | "segments" | "taxi";
            /** The colour of the edge's line. Colours may be specified by name (e.g. red), hex (e.g. */
            "line-color"?: string;
            /** The style of the edge's line. */
            "line-style"?: "solid" | "dotted" | "dashed";
            /** 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. */
            "line-cap"?: "butt" | "round" | "square";
            /** 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. */
            "line-opacity"?: number;
            /** The colour of the edge's source arrow. Colours may be specified by name (e.g. red), hex (e.g. */
            "target-arrow-color"?: string;
            /** The shape of the edge's source arrow */
            "target-arrow-shape"?:
              | "triangle"
              | "triangle-tee"
              | "circle-triangle"
              | "triangle-cross"
              | "triangle-backcurve"
              | "vee"
              | "tee"
              | "square"
              | "circle"
              | "diamond"
              | "chevron"
              | "none";
            /** The fill state of the edge's source arrow */
            "target-arrow-fill"?: "filled" | "hollow";
            /** The colour of the edge's source arrow. Colours may be specified by name (e.g. red), hex (e.g. */
            "mid-target-arrow-color"?: string;
            /** The shape of the edge's source arrow */
            "mid-target-arrow-shape"?:
              | "triangle"
              | "triangle-tee"
              | "circle-triangle"
              | "triangle-cross"
              | "triangle-backcurve"
              | "vee"
              | "tee"
              | "square"
              | "circle"
              | "diamond"
              | "chevron"
              | "none";
            /** The fill state of the edge's source arrow */
            "mid-target-arrow-fill"?: "filled" | "hollow";
            /** Scaling for the arrow size. */
            "arrow-scale"?: number;
            /** The text to display for an edge's source label. Can give a path, e.g. data(id) will label with the elements id */
            "source-label"?: string;
            /** The text to display for an edge's target label. Can give a path, e.g. data(id) will label with the elements id */
            "target-label"?: string;
          };
          /** Indicates whether the relationship should be treated as a logical representation only */
          isAnnotation?: boolean;
          [key: string]: any;
        };
        /** Model 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 */
        model: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The unique name for the model within the scope of a registrant. */
          name: string;
          /** Version of the model definition. */
          version: string;
          /** Human-readable name for the model. */
          displayName: string;
          /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
          model: {
            /** Version of the model as defined by the registrant. */
            version: string;
          };
          registrant: {
            /** Kind of the registrant. */
            kind: string;
          };
        };
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        modelId?: string;
        /** 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. */
        evaluationQuery?: string;
        /** 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. */
        selectors?: {
          /** Selectors used to define relationships which are allowed. */
          allow: {
            /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
            from: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id?: string;
              kind?: string;
              /** Match configuration for selector */
              match?: {
                refs?: string[][];
                from?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
                to?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
              };
              /** Match strategy matrix for the selector */
              match_strategy_matrix?: string[][];
              /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
              model?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id: string;
                /** The unique name for the model within the scope of a registrant. */
                name: string;
                /** Version of the model definition. */
                version: string;
                /** Human-readable name for the model. */
                displayName: string;
                /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
                model: {
                  /** Version of the model as defined by the registrant. */
                  version: string;
                };
                registrant: {
                  /** Kind of the registrant. */
                  kind: string;
                };
              };
              /** Patch configuration for the selector */
              patch?: {
                /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                                
                                add: Inserts a value into an array or adds a member to an object.
                                replace: Replaces a value.
                                merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                                strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                                remove: Removes a value.
                                copy: Copies a value from one location to another.
                                move: Moves a value from one location to another.
                                test: Tests that a value at the target location is equal to a specified value.
                                 */
                patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              };
            }[];
            /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
            to: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id?: string;
              kind?: string;
              /** Match configuration for selector */
              match?: {
                refs?: string[][];
                from?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
                to?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
              };
              /** Match strategy matrix for the selector */
              match_strategy_matrix?: string[][];
              /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
              model?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id: string;
                /** The unique name for the model within the scope of a registrant. */
                name: string;
                /** Version of the model definition. */
                version: string;
                /** Human-readable name for the model. */
                displayName: string;
                /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
                model: {
                  /** Version of the model as defined by the registrant. */
                  version: string;
                };
                registrant: {
                  /** Kind of the registrant. */
                  kind: string;
                };
              };
              /** Patch configuration for the selector */
              patch?: {
                /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                                
                                add: Inserts a value into an array or adds a member to an object.
                                replace: Replaces a value.
                                merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                                strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                                remove: Removes a value.
                                copy: Copies a value from one location to another.
                                move: Moves a value from one location to another.
                                test: Tests that a value at the target location is equal to a specified value.
                                 */
                patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              };
            }[];
          };
          /** Optional selectors used to define relationships which should not be created / is restricted. */
          deny?: {
            /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
            from: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id?: string;
              kind?: string;
              /** Match configuration for selector */
              match?: {
                refs?: string[][];
                from?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
                to?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
              };
              /** Match strategy matrix for the selector */
              match_strategy_matrix?: string[][];
              /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
              model?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id: string;
                /** The unique name for the model within the scope of a registrant. */
                name: string;
                /** Version of the model definition. */
                version: string;
                /** Human-readable name for the model. */
                displayName: string;
                /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
                model: {
                  /** Version of the model as defined by the registrant. */
                  version: string;
                };
                registrant: {
                  /** Kind of the registrant. */
                  kind: string;
                };
              };
              /** Patch configuration for the selector */
              patch?: {
                /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                                
                                add: Inserts a value into an array or adds a member to an object.
                                replace: Replaces a value.
                                merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                                strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                                remove: Removes a value.
                                copy: Copies a value from one location to another.
                                move: Moves a value from one location to another.
                                test: Tests that a value at the target location is equal to a specified value.
                                 */
                patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              };
            }[];
            /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
            to: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id?: string;
              kind?: string;
              /** Match configuration for selector */
              match?: {
                refs?: string[][];
                from?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
                to?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
              };
              /** Match strategy matrix for the selector */
              match_strategy_matrix?: string[][];
              /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
              model?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id: string;
                /** The unique name for the model within the scope of a registrant. */
                name: string;
                /** Version of the model definition. */
                version: string;
                /** Human-readable name for the model. */
                displayName: string;
                /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
                model: {
                  /** Version of the model as defined by the registrant. */
                  version: string;
                };
                registrant: {
                  /** Kind of the registrant. */
                  kind: string;
                };
              };
              /** Patch configuration for the selector */
              patch?: {
                /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                                
                                add: Inserts a value into an array or adds a member to an object.
                                replace: Replaces a value.
                                merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                                strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                                remove: Removes a value.
                                copy: Copies a value from one location to another.
                                move: Moves a value from one location to another.
                                test: Tests that a value at the target location is equal to a specified value.
                                 */
                patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              };
            }[];
          };
        }[];
      }[];
    };
    /** The options of the evaluationrequest. */
    options?: {
      /** If true, only return the diff of changes instead of the complete updated design */
      returnDiffOnly?: boolean;
      /** If true, include detailed trace information in the response */
      enableTrace?: boolean;
    };
  };
};
export type GetRegistryModelsApiResponse = /** status 200 Paginated list of registered models. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The models matching the query. */
  models?: ({
    /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
    id: string;
    /** Specifies the version of the schema used for the definition. */
    schemaVersion: string;
    /** Version of the model definition. */
    version: string;
    /** The unique name for the model within the scope of a registrant. */
    name: string;
    /** Human-readable name for the model. */
    displayName: string;
    /** Description of the model. */
    description: string;
    /** Status of model, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
    status: "ignored" | "enabled" | "duplicate";
    /** Connection identifying the entity that registered this model. */
    registrant: {
      /** Connection ID */
      id: string;
      /** Connection Name */
      name: string;
      /** Associated Credential ID */
      credentialId?: string;
      /** Connection Type (platform, telemetry, collaboration) */
      type: string;
      /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
      subType: string;
      /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
      kind: string;
      /** Additional connection metadata */
      metadata?: object;
      /** Connection Status */
      status:
        | "discovered"
        | "registered"
        | "connected"
        | "ignored"
        | "maintenance"
        | "disconnected"
        | "deleted"
        | "not found";
      /** User ID who owns this connection */
      user_id?: string;
      created_at?: string;
      updated_at?: string;
      /** SQL null Timestamp to handle null values of time. */
      deleted_at?: string;
      /** Associated environments for this connection */
      environments?: {
        /** ID */
        id: string;
        /** Specifies the version of the schema to which the environment conforms. */
        schemaVersion: string;
        /** Environment name */
        name: string;
        /** Environment description */
        description: string;
        /** Environment organization ID */
        organization_id: string;
        /** Environment owner */
        owner?: string;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Additional metadata associated with the environment. */
        metadata?: object;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
        /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
        deleted_at?: string | null;
      }[];
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
    };
    /** ID of the registrant. */
    registrantId: string;
    /** ID of the category. */
    categoryId: string;
    /** Category the model belongs to. */
    category: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The category of the model that determines the main grouping. */
      name:
        | "Analytics"
        | "App Definition and Development"
        | "Cloud Native Network"
        | "Cloud Native Storage"
        | "Database"
        | "Machine Learning"
        | "Observability and Analysis"
        | "Orchestration & Management"
        | "Platform"
        | "Provisioning"
        | "Runtime"
        | "Security & Compliance"
        | "Serverless"
        | "Tools"
        | "Uncategorized";
      /** Additional metadata associated with the category. */
      metadata: object;
    };
    /** Sub-category the model belongs to. */
    subCategory:
      | "API Gateway"
      | "API Integration"
      | "Application Definition & Image Build"
      | "Automation & Configuration"
      | "Certified Kubernetes - Distribution"
      | "Chaos Engineering"
      | "Cloud Native Storage"
      | "Cloud Provider"
      | "CNI"
      | "Compute"
      | "Container Registry"
      | "Container Runtime"
      | "Container Security"
      | "Container"
      | "Content Delivery Network"
      | "Continuous Integration & Delivery"
      | "Coordination & Service Discovery"
      | "Database"
      | "Flowchart"
      | "Framework"
      | "Installable Platform"
      | "Key Management"
      | "Key Management Service"
      | "Kubernetes"
      | "Logging"
      | "Machine Learning"
      | "Management Governance"
      | "Metrics"
      | "Monitoring"
      | "Networking Content Delivery"
      | "Operating System"
      | "Query"
      | "Remote Procedure Call"
      | "Scheduling & Orchestration"
      | "Secrets Management"
      | "Security Identity & Compliance"
      | "Service Mesh"
      | "Service Proxy"
      | "Source Version Control"
      | "Storage"
      | "Specifications"
      | "Streaming & Messaging"
      | "Tools"
      | "Tracing"
      | "Uncategorized"
      | "Video Conferencing";
    /** Metadata containing additional information associated with the model. */
    metadata?: {
      /** Capabilities associated with the model */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
      isAnnotation?: boolean;
      /** Primary color associated with the model. */
      primaryColor?: string;
      /** Secondary color associated with the model. */
      secondaryColor?: string;
      /** SVG representation of the model in white color. */
      svgWhite: string;
      /** SVG representation of the model in colored format. */
      svgColor: string;
      /** SVG representation of the complete model. */
      svgComplete?: string;
      /** Visual shape used to render the model's entities in design canvases. */
      shape?:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      [key: string]: any;
    };
    /** Registrant-defined data associated with the model. */
    model: {
      /** Version of the model as defined by the registrant. */
      version: string;
    };
    /** The relationships of the model. */
    relationships: any;
    /** The components of the model. */
    components: any;
    /** Number of components associated with the model. */
    componentsCount: number;
    /** Number of relationships associated with the model. */
    relationshipsCount: number;
    /** Timestamp when the model was created. */
    createdAt?: string;
    /** Timestamp when the model was last updated. */
    updatedAt?: string;
  } & {
    /** Number of other registered entries sharing this model's name and version. */
    duplicates?: number;
  })[];
};
export type GetRegistryModelsApiArg = {
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model status (e.g. `registered`, `ignored`, `duplicate`). */
  status?: string;
  /** Filter by model ID. */
  id?: string;
  /** Filter by the registrant (host) that registered the model. */
  registrant?: string;
  /** Filter by model version. */
  version?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
  /** When `true`, embeds the model's component definitions in the response. */
  components?: string;
  /** When `true`, embeds the model's relationship definitions in the response. */
  relationships?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
};
export type GetRegistryModelsByNameApiResponse = /** status 200 Paginated list of matching registered models. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The models matching the query. */
  models?: ({
    /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
    id: string;
    /** Specifies the version of the schema used for the definition. */
    schemaVersion: string;
    /** Version of the model definition. */
    version: string;
    /** The unique name for the model within the scope of a registrant. */
    name: string;
    /** Human-readable name for the model. */
    displayName: string;
    /** Description of the model. */
    description: string;
    /** Status of model, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
    status: "ignored" | "enabled" | "duplicate";
    /** Connection identifying the entity that registered this model. */
    registrant: {
      /** Connection ID */
      id: string;
      /** Connection Name */
      name: string;
      /** Associated Credential ID */
      credentialId?: string;
      /** Connection Type (platform, telemetry, collaboration) */
      type: string;
      /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
      subType: string;
      /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
      kind: string;
      /** Additional connection metadata */
      metadata?: object;
      /** Connection Status */
      status:
        | "discovered"
        | "registered"
        | "connected"
        | "ignored"
        | "maintenance"
        | "disconnected"
        | "deleted"
        | "not found";
      /** User ID who owns this connection */
      user_id?: string;
      created_at?: string;
      updated_at?: string;
      /** SQL null Timestamp to handle null values of time. */
      deleted_at?: string;
      /** Associated environments for this connection */
      environments?: {
        /** ID */
        id: string;
        /** Specifies the version of the schema to which the environment conforms. */
        schemaVersion: string;
        /** Environment name */
        name: string;
        /** Environment description */
        description: string;
        /** Environment organization ID */
        organization_id: string;
        /** Environment owner */
        owner?: string;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Additional metadata associated with the environment. */
        metadata?: object;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
        /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
        deleted_at?: string | null;
      }[];
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
    };
    /** ID of the registrant. */
    registrantId: string;
    /** ID of the category. */
    categoryId: string;
    /** Category the model belongs to. */
    category: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The category of the model that determines the main grouping. */
      name:
        | "Analytics"
        | "App Definition and Development"
        | "Cloud Native Network"
        | "Cloud Native Storage"
        | "Database"
        | "Machine Learning"
        | "Observability and Analysis"
        | "Orchestration & Management"
        | "Platform"
        | "Provisioning"
        | "Runtime"
        | "Security & Compliance"
        | "Serverless"
        | "Tools"
        | "Uncategorized";
      /** Additional metadata associated with the category. */
      metadata: object;
    };
    /** Sub-category the model belongs to. */
    subCategory:
      | "API Gateway"
      | "API Integration"
      | "Application Definition & Image Build"
      | "Automation & Configuration"
      | "Certified Kubernetes - Distribution"
      | "Chaos Engineering"
      | "Cloud Native Storage"
      | "Cloud Provider"
      | "CNI"
      | "Compute"
      | "Container Registry"
      | "Container Runtime"
      | "Container Security"
      | "Container"
      | "Content Delivery Network"
      | "Continuous Integration & Delivery"
      | "Coordination & Service Discovery"
      | "Database"
      | "Flowchart"
      | "Framework"
      | "Installable Platform"
      | "Key Management"
      | "Key Management Service"
      | "Kubernetes"
      | "Logging"
      | "Machine Learning"
      | "Management Governance"
      | "Metrics"
      | "Monitoring"
      | "Networking Content Delivery"
      | "Operating System"
      | "Query"
      | "Remote Procedure Call"
      | "Scheduling & Orchestration"
      | "Secrets Management"
      | "Security Identity & Compliance"
      | "Service Mesh"
      | "Service Proxy"
      | "Source Version Control"
      | "Storage"
      | "Specifications"
      | "Streaming & Messaging"
      | "Tools"
      | "Tracing"
      | "Uncategorized"
      | "Video Conferencing";
    /** Metadata containing additional information associated with the model. */
    metadata?: {
      /** Capabilities associated with the model */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
      isAnnotation?: boolean;
      /** Primary color associated with the model. */
      primaryColor?: string;
      /** Secondary color associated with the model. */
      secondaryColor?: string;
      /** SVG representation of the model in white color. */
      svgWhite: string;
      /** SVG representation of the model in colored format. */
      svgColor: string;
      /** SVG representation of the complete model. */
      svgComplete?: string;
      /** Visual shape used to render the model's entities in design canvases. */
      shape?:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      [key: string]: any;
    };
    /** Registrant-defined data associated with the model. */
    model: {
      /** Version of the model as defined by the registrant. */
      version: string;
    };
    /** The relationships of the model. */
    relationships: any;
    /** The components of the model. */
    components: any;
    /** Number of components associated with the model. */
    componentsCount: number;
    /** Number of relationships associated with the model. */
    relationshipsCount: number;
    /** Timestamp when the model was created. */
    createdAt?: string;
    /** Timestamp when the model was last updated. */
    updatedAt?: string;
  } & {
    /** Number of other registered entries sharing this model's name and version. */
    duplicates?: number;
  })[];
};
export type GetRegistryModelsByNameApiArg = {
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** When `true`, the model name is matched greedily (substring match). */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
  /** When `true`, embeds the model's component definitions in the response. */
  components?: string;
  /** When `true`, embeds the model's relationship definitions in the response. */
  relationships?: string;
};
export type DeleteRegistryModelApiResponse = unknown;
export type DeleteRegistryModelApiArg = {
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
};
export type GetRegistryComponentsByModelApiResponse =
  /** status 200 Paginated list of components belonging to the model. */ {
    /** Current page number of the result set. */
    page?: number;
    /** Number of items in the page. */
    pageSize?: number;
    /** Total number of items available. */
    totalCount?: number;
    /** Deprecated snake_case alias of `pageSize`. */
    page_size?: number;
    /** Deprecated snake_case alias of `totalCount`. */
    total_count?: number;
  } & {
    /** The components matching the query. */
    components?: ({
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema to which the component definition conforms. */
      schemaVersion: string;
      /** Version of the component definition. */
      version: string;
      /** Name of the component in human-readable format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the component. */
      description: string;
      /** Format specifies the format used in the `component.schema` field. JSON is the default. */
      format: "JSON" | "CUE";
      /** 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 */
      model: {
        /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
        id: string;
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
        /** Version of the model definition. */
        version: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Description of the model. */
        description: string;
        /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
        status: "ignored" | "enabled" | "duplicate";
        /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
        registrant: {
          /** Connection ID */
          id: string;
          /** Connection Name */
          name: string;
          /** Associated Credential ID */
          credentialId?: string;
          /** Connection Type (platform, telemetry, collaboration) */
          type: string;
          /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
          subType: string;
          /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
          kind: string;
          /** Additional connection metadata */
          metadata?: object;
          /** Connection Status */
          status:
            | "discovered"
            | "registered"
            | "connected"
            | "ignored"
            | "maintenance"
            | "disconnected"
            | "deleted"
            | "not found";
          /** User ID who owns this connection */
          user_id?: string;
          created_at?: string;
          updated_at?: string;
          /** SQL null Timestamp to handle null values of time. */
          deleted_at?: string;
          /** Associated environments for this connection */
          environments?: {
            /** ID */
            id: string;
            /** Specifies the version of the schema to which the environment conforms. */
            schemaVersion: string;
            /** Environment name */
            name: string;
            /** Environment description */
            description: string;
            /** Environment organization ID */
            organization_id: string;
            /** Environment owner */
            owner?: string;
            /** Timestamp when the resource was created. */
            created_at?: string;
            /** Additional metadata associated with the environment. */
            metadata?: object;
            /** Timestamp when the resource was updated. */
            updated_at?: string;
            /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
            deleted_at?: string | null;
          }[];
          /** Specifies the version of the schema used for the definition. */
          schemaVersion: string;
        };
        /** ID of the registrant. */
        registrantId: string;
        /** ID of the category. */
        categoryId: string;
        /** Category of the model. */
        category: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The category of the model that determines the main grouping. */
          name:
            | "Analytics"
            | "App Definition and Development"
            | "Cloud Native Network"
            | "Cloud Native Storage"
            | "Database"
            | "Machine Learning"
            | "Observability and Analysis"
            | "Orchestration & Management"
            | "Platform"
            | "Provisioning"
            | "Runtime"
            | "Security & Compliance"
            | "Serverless"
            | "Tools"
            | "Uncategorized";
          /** Additional metadata associated with the category. */
          metadata: object;
        };
        /** Sub category of the model determines the secondary grouping. */
        subCategory:
          | "API Gateway"
          | "API Integration"
          | "Application Definition & Image Build"
          | "Automation & Configuration"
          | "Certified Kubernetes - Distribution"
          | "Chaos Engineering"
          | "Cloud Native Storage"
          | "Cloud Provider"
          | "CNI"
          | "Compute"
          | "Container Registry"
          | "Container Runtime"
          | "Container Security"
          | "Container"
          | "Content Delivery Network"
          | "Continuous Integration & Delivery"
          | "Coordination & Service Discovery"
          | "Database"
          | "Flowchart"
          | "Framework"
          | "Installable Platform"
          | "Key Management"
          | "Key Management Service"
          | "Kubernetes"
          | "Logging"
          | "Machine Learning"
          | "Management Governance"
          | "Metrics"
          | "Monitoring"
          | "Networking Content Delivery"
          | "Operating System"
          | "Query"
          | "Remote Procedure Call"
          | "Scheduling & Orchestration"
          | "Secrets Management"
          | "Security Identity & Compliance"
          | "Service Mesh"
          | "Service Proxy"
          | "Source Version Control"
          | "Storage"
          | "Specifications"
          | "Streaming & Messaging"
          | "Tools"
          | "Tracing"
          | "Uncategorized"
          | "Video Conferencing";
        /** Metadata containing additional information associated with the model. */
        metadata?: {
          /** Capabilities associated with the model */
          capabilities?: {
            /** Specifies the version of the schema to which the capability definition conforms. */
            schemaVersion: string;
            /** Version of the capability definition. */
            version: string;
            /** Name of the capability in human-readible format. */
            displayName: string;
            /** A written representation of the purpose and characteristics of the capability. */
            description: string;
            /** Top-level categorization of the capability */
            kind: "action" | "mutate" | "view" | "interaction";
            /** Classification of capabilities. Used to group capabilities similar in nature. */
            type: string;
            /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
            subType: string;
            /** Key that backs the capability. */
            key: string;
            /** State of the entity in which the capability is applicable. */
            entityState: ("declaration" | "instance")[];
            /** Status of the capability */
            status: "enabled" | "disabled";
            /** Metadata contains additional information associated with the capability. Extension point. */
            metadata?: {
              [key: string]: any;
            };
          }[];
          /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
          isAnnotation?: boolean;
          /** Primary color associated with the model. */
          primaryColor?: string;
          /** Secondary color associated with the model. */
          secondaryColor?: string;
          /** SVG representation of the model in white color. */
          svgWhite: string;
          /** SVG representation of the model in colored format. */
          svgColor: string;
          /** SVG representation of the complete model. */
          svgComplete?: string;
          /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
          shape?:
            | "ellipse"
            | "triangle"
            | "round-triangle"
            | "rectangle"
            | "round-rectangle"
            | "bottom-round-rectangle"
            | "cut-rectangle"
            | "barrel"
            | "rhomboid"
            | "diamond"
            | "round-diamond"
            | "pentagon"
            | "round-pentagon"
            | "hexagon"
            | "round-hexagon"
            | "concave-hexagon"
            | "heptagon"
            | "round-heptagon"
            | "octagon"
            | "round-octagon"
            | "star"
            | "tag"
            | "round-tag"
            | "vee"
            | "polygon";
          [key: string]: any;
        };
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        /** The relationships of the model. */
        relationships: any;
        /** The components of the model. */
        components: any;
        /** Number of components associated with the model. */
        componentsCount: number;
        /** Number of relationships associated with the model. */
        relationshipsCount: number;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
      };
      /** 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 */
      modelReference: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
      modelId?: string;
      /** Visualization styles for a component */
      styles?: {
        /** Primary color of the component used for UI representation. */
        primaryColor: string;
        /** Secondary color of the entity used for UI representation. */
        secondaryColor?: string;
        /** White SVG of the entity used for UI representation on dark background. */
        svgWhite: string;
        /** Colored SVG of the entity used for UI representation on light background. */
        svgColor: string;
        /** Complete SVG of the entity used for UI representation, often inclusive of background. */
        svgComplete: string;
        /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
        color?: string;
        /** The opacity of the label text, including its outline. */
        textOpacity?: number;
        /** A comma-separated list of font names to use on the label text. */
        fontFamily?: string;
        /** The size of the label text. */
        fontSize?: string;
        /** A CSS font style to be applied to the label text. */
        fontStyle?: string;
        /** A CSS font weight to be applied to the label text. */
        fontWeight?: string;
        /** A transformation to apply to the label text */
        textTransform?: "none" | "uppercase" | "lowercase";
        /** 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. */
        opacity?: number;
        /** 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. */
        zIndex?: number;
        /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
        label?: string;
        /** The animation to apply to the element. example ripple,bounce,etc */
        animation?: object;
        [key: string]: any;
      } & {
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
        position?: {
          /** The x-coordinate of the node. */
          x: number;
          /** The y-coordinate of the node. */
          y: number;
        };
        /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
        bodyText?: string;
        /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
        bodyTextWrap?: "none" | "wrap" | "ellipsis";
        /** The maximum width for wrapping text in the node. */
        bodyTextMaxWidth?: string;
        /** The opacity of the node's body text, including its outline. */
        bodyTextOpacity?: number;
        /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextBackgroundColor?: string;
        /** The size of the node's body text. */
        bodyTextFontSize?: number;
        /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextColor?: string;
        /** A CSS font weight to be applied to the node's body text. */
        bodyTextFontWeight?: string;
        /** A CSS horizontal alignment to be applied to the node's body text. */
        bodyTextHorizontalAlign?: string;
        /** A CSS text decoration to be applied to the node's body text. */
        bodyTextDecoration?: string;
        /** A CSS vertical alignment to be applied to the node's body text. */
        bodyTextVerticalAlign?: string;
        /** The width of the node's body or the width of an edge's line. */
        width?: number;
        /** The height of the node's body */
        height?: number;
        /** The URL that points to the image to show in the node. */
        backgroundImage?: string;
        /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
        backgroundColor?: string;
        /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
        backgroundBlacken?: number;
        /** The opacity level of the node's background colour */
        backgroundOpacity?: number;
        /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionX?: string;
        /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionY?: string;
        /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetX?: string;
        /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetY?: string;
        /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
        backgroundFit?: "none" | "contain" | "cover";
        /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
        backgroundClip?: "none" | "node" | "node-border";
        /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundWidthRelativeTo?: "none" | "inner" | "outer";
        /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundHeightRelativeTo?: "none" | "inner" | "outer";
        /** The size of the node's border. */
        borderWidth?: number;
        /** The style of the node's border */
        borderStyle?: "solid" | "dotted" | "dashed" | "double";
        /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
        borderColor?: string;
        /** The opacity of the node's border */
        borderOpacity?: number;
        /** The amount of padding around all sides of the node. */
        padding?: number;
        /** The horizontal alignment of a node's label */
        textHalign?: "left" | "center" | "right";
        /** The vertical alignment of a node's label */
        textValign?: "top" | "center" | "bottom";
        /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
        ghost?: "yes" | "no";
        /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        activeBgColor?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgOpacity?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgSize?: string;
        /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        selectionBoxColor?: string;
        /** The size of the border on the selection box. Selector needs to be *core* */
        selectionBoxBorderWidth?: number;
        /** The opacity of the selection box. Selector needs to be *core* */
        selectionBoxOpacity?: number;
        /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        outsideTextureBgColor?: string;
        /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
        outsideTextureBgOpacity?: number;
        /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
        shapePolygonPoints?: string;
        /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuBackgroundColor?: string;
        /** The opacity of the background of the component menu. */
        menuBackgroundOpacity?: number;
        /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuForgroundColor?: string;
      };
      /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
      status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
      /** Metadata contains additional information associated with the component. */
      metadata: {
        /** Genealogy represents the various representational states of the component. */
        genealogy: string;
        /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
        isAnnotation: boolean;
        /** Identifies whether the component is scoped to namespace or cluster wide. */
        isNamespaced: boolean;
        /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
        published: boolean;
        /** InstanceDetails contains information about the instance of the component. */
        instanceDetails: object;
        /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
        configurationUISchema: string;
        [key: string]: any;
      };
      /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
      configuration: object;
      /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
      component: {
        /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
        version: string;
        /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
        kind: string;
        /** JSON schema of the object as defined by the registrant. */
        schema: string;
      };
      /** Timestamp when the component was created. */
      createdAt: string;
      /** Timestamp when the component was last updated. */
      updatedAt: string;
      /** Timestamp when the component was soft-deleted. Null while the component is active. */
      deletedAt?: string;
    } & {
      /** Number of other registered entries sharing this component's kind, version, and model. */
      duplicates?: number;
    })[];
  };
export type GetRegistryComponentsByModelApiArg = {
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Filter components by their API version. */
  apiVersion?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
};
export type GetRegistryComponentsByModelAndNameApiResponse = /** status 200 Paginated list of matching components. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The components matching the query. */
  components?: ({
    /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
    id: string;
    /** Specifies the version of the schema to which the component definition conforms. */
    schemaVersion: string;
    /** Version of the component definition. */
    version: string;
    /** Name of the component in human-readable format. */
    displayName: string;
    /** A written representation of the purpose and characteristics of the component. */
    description: string;
    /** Format specifies the format used in the `component.schema` field. JSON is the default. */
    format: "JSON" | "CUE";
    /** 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 */
    model: {
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
      /** Version of the model definition. */
      version: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Description of the model. */
      description: string;
      /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
      status: "ignored" | "enabled" | "duplicate";
      /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
      registrant: {
        /** Connection ID */
        id: string;
        /** Connection Name */
        name: string;
        /** Associated Credential ID */
        credentialId?: string;
        /** Connection Type (platform, telemetry, collaboration) */
        type: string;
        /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
        subType: string;
        /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
        kind: string;
        /** Additional connection metadata */
        metadata?: object;
        /** Connection Status */
        status:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** User ID who owns this connection */
        user_id?: string;
        created_at?: string;
        updated_at?: string;
        /** SQL null Timestamp to handle null values of time. */
        deleted_at?: string;
        /** Associated environments for this connection */
        environments?: {
          /** ID */
          id: string;
          /** Specifies the version of the schema to which the environment conforms. */
          schemaVersion: string;
          /** Environment name */
          name: string;
          /** Environment description */
          description: string;
          /** Environment organization ID */
          organization_id: string;
          /** Environment owner */
          owner?: string;
          /** Timestamp when the resource was created. */
          created_at?: string;
          /** Additional metadata associated with the environment. */
          metadata?: object;
          /** Timestamp when the resource was updated. */
          updated_at?: string;
          /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
          deleted_at?: string | null;
        }[];
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
      };
      /** ID of the registrant. */
      registrantId: string;
      /** ID of the category. */
      categoryId: string;
      /** Category of the model. */
      category: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The category of the model that determines the main grouping. */
        name:
          | "Analytics"
          | "App Definition and Development"
          | "Cloud Native Network"
          | "Cloud Native Storage"
          | "Database"
          | "Machine Learning"
          | "Observability and Analysis"
          | "Orchestration & Management"
          | "Platform"
          | "Provisioning"
          | "Runtime"
          | "Security & Compliance"
          | "Serverless"
          | "Tools"
          | "Uncategorized";
        /** Additional metadata associated with the category. */
        metadata: object;
      };
      /** Sub category of the model determines the secondary grouping. */
      subCategory:
        | "API Gateway"
        | "API Integration"
        | "Application Definition & Image Build"
        | "Automation & Configuration"
        | "Certified Kubernetes - Distribution"
        | "Chaos Engineering"
        | "Cloud Native Storage"
        | "Cloud Provider"
        | "CNI"
        | "Compute"
        | "Container Registry"
        | "Container Runtime"
        | "Container Security"
        | "Container"
        | "Content Delivery Network"
        | "Continuous Integration & Delivery"
        | "Coordination & Service Discovery"
        | "Database"
        | "Flowchart"
        | "Framework"
        | "Installable Platform"
        | "Key Management"
        | "Key Management Service"
        | "Kubernetes"
        | "Logging"
        | "Machine Learning"
        | "Management Governance"
        | "Metrics"
        | "Monitoring"
        | "Networking Content Delivery"
        | "Operating System"
        | "Query"
        | "Remote Procedure Call"
        | "Scheduling & Orchestration"
        | "Secrets Management"
        | "Security Identity & Compliance"
        | "Service Mesh"
        | "Service Proxy"
        | "Source Version Control"
        | "Storage"
        | "Specifications"
        | "Streaming & Messaging"
        | "Tools"
        | "Tracing"
        | "Uncategorized"
        | "Video Conferencing";
      /** Metadata containing additional information associated with the model. */
      metadata?: {
        /** Capabilities associated with the model */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
        isAnnotation?: boolean;
        /** Primary color associated with the model. */
        primaryColor?: string;
        /** Secondary color associated with the model. */
        secondaryColor?: string;
        /** SVG representation of the model in white color. */
        svgWhite: string;
        /** SVG representation of the model in colored format. */
        svgColor: string;
        /** SVG representation of the complete model. */
        svgComplete?: string;
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape?:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        [key: string]: any;
      };
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      /** The relationships of the model. */
      relationships: any;
      /** The components of the model. */
      components: any;
      /** Number of components associated with the model. */
      componentsCount: number;
      /** Number of relationships associated with the model. */
      relationshipsCount: number;
      /** Timestamp when the resource was created. */
      created_at?: string;
      /** Timestamp when the resource was updated. */
      updated_at?: string;
    };
    /** 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 */
    modelReference: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Version of the model definition. */
      version: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      registrant: {
        /** Kind of the registrant. */
        kind: string;
      };
    };
    /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
    modelId?: string;
    /** Visualization styles for a component */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
    capabilities?: {
      /** Specifies the version of the schema to which the capability definition conforms. */
      schemaVersion: string;
      /** Version of the capability definition. */
      version: string;
      /** Name of the capability in human-readible format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the capability. */
      description: string;
      /** Top-level categorization of the capability */
      kind: "action" | "mutate" | "view" | "interaction";
      /** Classification of capabilities. Used to group capabilities similar in nature. */
      type: string;
      /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
      subType: string;
      /** Key that backs the capability. */
      key: string;
      /** State of the entity in which the capability is applicable. */
      entityState: ("declaration" | "instance")[];
      /** Status of the capability */
      status: "enabled" | "disabled";
      /** Metadata contains additional information associated with the capability. Extension point. */
      metadata?: {
        [key: string]: any;
      };
    }[];
    /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
    status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
    /** Metadata contains additional information associated with the component. */
    metadata: {
      /** Genealogy represents the various representational states of the component. */
      genealogy: string;
      /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
      isAnnotation: boolean;
      /** Identifies whether the component is scoped to namespace or cluster wide. */
      isNamespaced: boolean;
      /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
      published: boolean;
      /** InstanceDetails contains information about the instance of the component. */
      instanceDetails: object;
      /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
      configurationUISchema: string;
      [key: string]: any;
    };
    /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
    configuration: object;
    /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
    component: {
      /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
      version: string;
      /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
      kind: string;
      /** JSON schema of the object as defined by the registrant. */
      schema: string;
    };
    /** Timestamp when the component was created. */
    createdAt: string;
    /** Timestamp when the component was last updated. */
    updatedAt: string;
    /** Timestamp when the component was soft-deleted. Null while the component is active. */
    deletedAt?: string;
  } & {
    /** Number of other registered entries sharing this component's kind, version, and model. */
    duplicates?: number;
  })[];
};
export type GetRegistryComponentsByModelAndNameApiArg = {
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Kind of the component (e.g. `Deployment`). */
  name: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Filter components by their API version. */
  apiVersion?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
};
export type GetRegistryRelationshipsByModelApiResponse =
  /** status 200 Paginated list of relationships belonging to the model. */ {
    /** Current page number of the result set. */
    page?: number;
    /** Number of items in the page. */
    pageSize?: number;
    /** Total number of items available. */
    totalCount?: number;
    /** Deprecated snake_case alias of `pageSize`. */
    page_size?: number;
    /** Deprecated snake_case alias of `totalCount`. */
    total_count?: number;
  } & {
    /** The relationships matching the query. */
    relationships?: any[];
  };
export type GetRegistryRelationshipsByModelApiArg = {
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
};
export type GetRegistryRelationshipsByModelAndNameApiResponse =
  /** status 200 Paginated list of matching relationships. */ {
    /** Current page number of the result set. */
    page?: number;
    /** Number of items in the page. */
    pageSize?: number;
    /** Total number of items available. */
    totalCount?: number;
    /** Deprecated snake_case alias of `pageSize`. */
    page_size?: number;
    /** Deprecated snake_case alias of `totalCount`. */
    total_count?: number;
  } & {
    /** The relationships matching the query. */
    relationships?: any[];
  };
export type GetRegistryRelationshipsByModelAndNameApiArg = {
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Kind of the relationship (e.g. `hierarchical`, `edge`, `sibling`). */
  name: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
};
export type GetRegistryPoliciesByModelApiResponse =
  /** status 200 Paginated list of policies belonging to the model. */ {
    /** Current page number of the result set. */
    page?: number;
    /** Number of items in the page. */
    pageSize?: number;
    /** Total number of items available. */
    totalCount?: number;
    /** Deprecated snake_case alias of `pageSize`. */
    page_size?: number;
    /** Deprecated snake_case alias of `totalCount`. */
    total_count?: number;
  } & {
    /** The policies matching the query. */
    policies?: {
      [key: string]: any;
    }[];
  };
export type GetRegistryPoliciesByModelApiArg = {
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
};
export type GetRegistryPoliciesByModelAndNameApiResponse = /** status 200 Paginated list of matching policies. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The policies matching the query. */
  policies?: {
    [key: string]: any;
  }[];
};
export type GetRegistryPoliciesByModelAndNameApiArg = {
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Name of the policy. */
  name: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
};
export type GetRegistryCategoriesApiResponse = /** status 200 Paginated list of categories. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The categories matching the query. */
  categories?: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    id: string;
    /** The category of the model that determines the main grouping. */
    name:
      | "Analytics"
      | "App Definition and Development"
      | "Cloud Native Network"
      | "Cloud Native Storage"
      | "Database"
      | "Machine Learning"
      | "Observability and Analysis"
      | "Orchestration & Management"
      | "Platform"
      | "Provisioning"
      | "Runtime"
      | "Security & Compliance"
      | "Serverless"
      | "Tools"
      | "Uncategorized";
    /** Additional metadata associated with the category. */
    metadata: object;
  }[];
};
export type GetRegistryCategoriesApiArg = {
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
};
export type GetRegistryCategoriesByNameApiResponse = /** status 200 Paginated list of matching categories. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The categories matching the query. */
  categories?: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    id: string;
    /** The category of the model that determines the main grouping. */
    name:
      | "Analytics"
      | "App Definition and Development"
      | "Cloud Native Network"
      | "Cloud Native Storage"
      | "Database"
      | "Machine Learning"
      | "Observability and Analysis"
      | "Orchestration & Management"
      | "Platform"
      | "Provisioning"
      | "Runtime"
      | "Security & Compliance"
      | "Serverless"
      | "Tools"
      | "Uncategorized";
    /** Additional metadata associated with the category. */
    metadata: object;
  }[];
};
export type GetRegistryCategoriesByNameApiArg = {
  /** Name of the category. */
  category: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** When `true`, the category name is matched greedily (substring match). */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
};
export type GetRegistryModelsByCategoryApiResponse = /** status 200 Paginated list of models in the category. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The models matching the query. */
  models?: ({
    /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
    id: string;
    /** Specifies the version of the schema used for the definition. */
    schemaVersion: string;
    /** Version of the model definition. */
    version: string;
    /** The unique name for the model within the scope of a registrant. */
    name: string;
    /** Human-readable name for the model. */
    displayName: string;
    /** Description of the model. */
    description: string;
    /** Status of model, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
    status: "ignored" | "enabled" | "duplicate";
    /** Connection identifying the entity that registered this model. */
    registrant: {
      /** Connection ID */
      id: string;
      /** Connection Name */
      name: string;
      /** Associated Credential ID */
      credentialId?: string;
      /** Connection Type (platform, telemetry, collaboration) */
      type: string;
      /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
      subType: string;
      /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
      kind: string;
      /** Additional connection metadata */
      metadata?: object;
      /** Connection Status */
      status:
        | "discovered"
        | "registered"
        | "connected"
        | "ignored"
        | "maintenance"
        | "disconnected"
        | "deleted"
        | "not found";
      /** User ID who owns this connection */
      user_id?: string;
      created_at?: string;
      updated_at?: string;
      /** SQL null Timestamp to handle null values of time. */
      deleted_at?: string;
      /** Associated environments for this connection */
      environments?: {
        /** ID */
        id: string;
        /** Specifies the version of the schema to which the environment conforms. */
        schemaVersion: string;
        /** Environment name */
        name: string;
        /** Environment description */
        description: string;
        /** Environment organization ID */
        organization_id: string;
        /** Environment owner */
        owner?: string;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Additional metadata associated with the environment. */
        metadata?: object;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
        /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
        deleted_at?: string | null;
      }[];
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
    };
    /** ID of the registrant. */
    registrantId: string;
    /** ID of the category. */
    categoryId: string;
    /** Category the model belongs to. */
    category: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The category of the model that determines the main grouping. */
      name:
        | "Analytics"
        | "App Definition and Development"
        | "Cloud Native Network"
        | "Cloud Native Storage"
        | "Database"
        | "Machine Learning"
        | "Observability and Analysis"
        | "Orchestration & Management"
        | "Platform"
        | "Provisioning"
        | "Runtime"
        | "Security & Compliance"
        | "Serverless"
        | "Tools"
        | "Uncategorized";
      /** Additional metadata associated with the category. */
      metadata: object;
    };
    /** Sub-category the model belongs to. */
    subCategory:
      | "API Gateway"
      | "API Integration"
      | "Application Definition & Image Build"
      | "Automation & Configuration"
      | "Certified Kubernetes - Distribution"
      | "Chaos Engineering"
      | "Cloud Native Storage"
      | "Cloud Provider"
      | "CNI"
      | "Compute"
      | "Container Registry"
      | "Container Runtime"
      | "Container Security"
      | "Container"
      | "Content Delivery Network"
      | "Continuous Integration & Delivery"
      | "Coordination & Service Discovery"
      | "Database"
      | "Flowchart"
      | "Framework"
      | "Installable Platform"
      | "Key Management"
      | "Key Management Service"
      | "Kubernetes"
      | "Logging"
      | "Machine Learning"
      | "Management Governance"
      | "Metrics"
      | "Monitoring"
      | "Networking Content Delivery"
      | "Operating System"
      | "Query"
      | "Remote Procedure Call"
      | "Scheduling & Orchestration"
      | "Secrets Management"
      | "Security Identity & Compliance"
      | "Service Mesh"
      | "Service Proxy"
      | "Source Version Control"
      | "Storage"
      | "Specifications"
      | "Streaming & Messaging"
      | "Tools"
      | "Tracing"
      | "Uncategorized"
      | "Video Conferencing";
    /** Metadata containing additional information associated with the model. */
    metadata?: {
      /** Capabilities associated with the model */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
      isAnnotation?: boolean;
      /** Primary color associated with the model. */
      primaryColor?: string;
      /** Secondary color associated with the model. */
      secondaryColor?: string;
      /** SVG representation of the model in white color. */
      svgWhite: string;
      /** SVG representation of the model in colored format. */
      svgColor: string;
      /** SVG representation of the complete model. */
      svgComplete?: string;
      /** Visual shape used to render the model's entities in design canvases. */
      shape?:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      [key: string]: any;
    };
    /** Registrant-defined data associated with the model. */
    model: {
      /** Version of the model as defined by the registrant. */
      version: string;
    };
    /** The relationships of the model. */
    relationships: any;
    /** The components of the model. */
    components: any;
    /** Number of components associated with the model. */
    componentsCount: number;
    /** Number of relationships associated with the model. */
    relationshipsCount: number;
    /** Timestamp when the model was created. */
    createdAt?: string;
    /** Timestamp when the model was last updated. */
    updatedAt?: string;
  } & {
    /** Number of other registered entries sharing this model's name and version. */
    duplicates?: number;
  })[];
};
export type GetRegistryModelsByCategoryApiArg = {
  /** Name of the category. */
  category: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
  /** When `true`, embeds the model's component definitions in the response. */
  components?: string;
  /** When `true`, embeds the model's relationship definitions in the response. */
  relationships?: string;
};
export type GetRegistryModelsByCategoryAndModelApiResponse =
  /** status 200 Paginated list of matching models in the category. */ {
    /** Current page number of the result set. */
    page?: number;
    /** Number of items in the page. */
    pageSize?: number;
    /** Total number of items available. */
    totalCount?: number;
    /** Deprecated snake_case alias of `pageSize`. */
    page_size?: number;
    /** Deprecated snake_case alias of `totalCount`. */
    total_count?: number;
  } & {
    /** The models matching the query. */
    models?: ({
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
      /** Version of the model definition. */
      version: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Description of the model. */
      description: string;
      /** Status of model, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
      status: "ignored" | "enabled" | "duplicate";
      /** Connection identifying the entity that registered this model. */
      registrant: {
        /** Connection ID */
        id: string;
        /** Connection Name */
        name: string;
        /** Associated Credential ID */
        credentialId?: string;
        /** Connection Type (platform, telemetry, collaboration) */
        type: string;
        /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
        subType: string;
        /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
        kind: string;
        /** Additional connection metadata */
        metadata?: object;
        /** Connection Status */
        status:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** User ID who owns this connection */
        user_id?: string;
        created_at?: string;
        updated_at?: string;
        /** SQL null Timestamp to handle null values of time. */
        deleted_at?: string;
        /** Associated environments for this connection */
        environments?: {
          /** ID */
          id: string;
          /** Specifies the version of the schema to which the environment conforms. */
          schemaVersion: string;
          /** Environment name */
          name: string;
          /** Environment description */
          description: string;
          /** Environment organization ID */
          organization_id: string;
          /** Environment owner */
          owner?: string;
          /** Timestamp when the resource was created. */
          created_at?: string;
          /** Additional metadata associated with the environment. */
          metadata?: object;
          /** Timestamp when the resource was updated. */
          updated_at?: string;
          /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
          deleted_at?: string | null;
        }[];
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
      };
      /** ID of the registrant. */
      registrantId: string;
      /** ID of the category. */
      categoryId: string;
      /** Category the model belongs to. */
      category: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The category of the model that determines the main grouping. */
        name:
          | "Analytics"
          | "App Definition and Development"
          | "Cloud Native Network"
          | "Cloud Native Storage"
          | "Database"
          | "Machine Learning"
          | "Observability and Analysis"
          | "Orchestration & Management"
          | "Platform"
          | "Provisioning"
          | "Runtime"
          | "Security & Compliance"
          | "Serverless"
          | "Tools"
          | "Uncategorized";
        /** Additional metadata associated with the category. */
        metadata: object;
      };
      /** Sub-category the model belongs to. */
      subCategory:
        | "API Gateway"
        | "API Integration"
        | "Application Definition & Image Build"
        | "Automation & Configuration"
        | "Certified Kubernetes - Distribution"
        | "Chaos Engineering"
        | "Cloud Native Storage"
        | "Cloud Provider"
        | "CNI"
        | "Compute"
        | "Container Registry"
        | "Container Runtime"
        | "Container Security"
        | "Container"
        | "Content Delivery Network"
        | "Continuous Integration & Delivery"
        | "Coordination & Service Discovery"
        | "Database"
        | "Flowchart"
        | "Framework"
        | "Installable Platform"
        | "Key Management"
        | "Key Management Service"
        | "Kubernetes"
        | "Logging"
        | "Machine Learning"
        | "Management Governance"
        | "Metrics"
        | "Monitoring"
        | "Networking Content Delivery"
        | "Operating System"
        | "Query"
        | "Remote Procedure Call"
        | "Scheduling & Orchestration"
        | "Secrets Management"
        | "Security Identity & Compliance"
        | "Service Mesh"
        | "Service Proxy"
        | "Source Version Control"
        | "Storage"
        | "Specifications"
        | "Streaming & Messaging"
        | "Tools"
        | "Tracing"
        | "Uncategorized"
        | "Video Conferencing";
      /** Metadata containing additional information associated with the model. */
      metadata?: {
        /** Capabilities associated with the model */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
        isAnnotation?: boolean;
        /** Primary color associated with the model. */
        primaryColor?: string;
        /** Secondary color associated with the model. */
        secondaryColor?: string;
        /** SVG representation of the model in white color. */
        svgWhite: string;
        /** SVG representation of the model in colored format. */
        svgColor: string;
        /** SVG representation of the complete model. */
        svgComplete?: string;
        /** Visual shape used to render the model's entities in design canvases. */
        shape?:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        [key: string]: any;
      };
      /** Registrant-defined data associated with the model. */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      /** The relationships of the model. */
      relationships: any;
      /** The components of the model. */
      components: any;
      /** Number of components associated with the model. */
      componentsCount: number;
      /** Number of relationships associated with the model. */
      relationshipsCount: number;
      /** Timestamp when the model was created. */
      createdAt?: string;
      /** Timestamp when the model was last updated. */
      updatedAt?: string;
    } & {
      /** Number of other registered entries sharing this model's name and version. */
      duplicates?: number;
    })[];
  };
export type GetRegistryModelsByCategoryAndModelApiArg = {
  /** Name of the category. */
  category: string;
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** When `true`, the model name is matched greedily (substring match). */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
  /** When `true`, embeds the model's component definitions in the response. */
  components?: string;
  /** When `true`, embeds the model's relationship definitions in the response. */
  relationships?: string;
};
export type GetRegistryComponentsByCategoryAndModelApiResponse = /** status 200 Paginated list of components. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The components matching the query. */
  components?: ({
    /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
    id: string;
    /** Specifies the version of the schema to which the component definition conforms. */
    schemaVersion: string;
    /** Version of the component definition. */
    version: string;
    /** Name of the component in human-readable format. */
    displayName: string;
    /** A written representation of the purpose and characteristics of the component. */
    description: string;
    /** Format specifies the format used in the `component.schema` field. JSON is the default. */
    format: "JSON" | "CUE";
    /** 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 */
    model: {
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
      /** Version of the model definition. */
      version: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Description of the model. */
      description: string;
      /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
      status: "ignored" | "enabled" | "duplicate";
      /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
      registrant: {
        /** Connection ID */
        id: string;
        /** Connection Name */
        name: string;
        /** Associated Credential ID */
        credentialId?: string;
        /** Connection Type (platform, telemetry, collaboration) */
        type: string;
        /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
        subType: string;
        /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
        kind: string;
        /** Additional connection metadata */
        metadata?: object;
        /** Connection Status */
        status:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** User ID who owns this connection */
        user_id?: string;
        created_at?: string;
        updated_at?: string;
        /** SQL null Timestamp to handle null values of time. */
        deleted_at?: string;
        /** Associated environments for this connection */
        environments?: {
          /** ID */
          id: string;
          /** Specifies the version of the schema to which the environment conforms. */
          schemaVersion: string;
          /** Environment name */
          name: string;
          /** Environment description */
          description: string;
          /** Environment organization ID */
          organization_id: string;
          /** Environment owner */
          owner?: string;
          /** Timestamp when the resource was created. */
          created_at?: string;
          /** Additional metadata associated with the environment. */
          metadata?: object;
          /** Timestamp when the resource was updated. */
          updated_at?: string;
          /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
          deleted_at?: string | null;
        }[];
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
      };
      /** ID of the registrant. */
      registrantId: string;
      /** ID of the category. */
      categoryId: string;
      /** Category of the model. */
      category: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The category of the model that determines the main grouping. */
        name:
          | "Analytics"
          | "App Definition and Development"
          | "Cloud Native Network"
          | "Cloud Native Storage"
          | "Database"
          | "Machine Learning"
          | "Observability and Analysis"
          | "Orchestration & Management"
          | "Platform"
          | "Provisioning"
          | "Runtime"
          | "Security & Compliance"
          | "Serverless"
          | "Tools"
          | "Uncategorized";
        /** Additional metadata associated with the category. */
        metadata: object;
      };
      /** Sub category of the model determines the secondary grouping. */
      subCategory:
        | "API Gateway"
        | "API Integration"
        | "Application Definition & Image Build"
        | "Automation & Configuration"
        | "Certified Kubernetes - Distribution"
        | "Chaos Engineering"
        | "Cloud Native Storage"
        | "Cloud Provider"
        | "CNI"
        | "Compute"
        | "Container Registry"
        | "Container Runtime"
        | "Container Security"
        | "Container"
        | "Content Delivery Network"
        | "Continuous Integration & Delivery"
        | "Coordination & Service Discovery"
        | "Database"
        | "Flowchart"
        | "Framework"
        | "Installable Platform"
        | "Key Management"
        | "Key Management Service"
        | "Kubernetes"
        | "Logging"
        | "Machine Learning"
        | "Management Governance"
        | "Metrics"
        | "Monitoring"
        | "Networking Content Delivery"
        | "Operating System"
        | "Query"
        | "Remote Procedure Call"
        | "Scheduling & Orchestration"
        | "Secrets Management"
        | "Security Identity & Compliance"
        | "Service Mesh"
        | "Service Proxy"
        | "Source Version Control"
        | "Storage"
        | "Specifications"
        | "Streaming & Messaging"
        | "Tools"
        | "Tracing"
        | "Uncategorized"
        | "Video Conferencing";
      /** Metadata containing additional information associated with the model. */
      metadata?: {
        /** Capabilities associated with the model */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
        isAnnotation?: boolean;
        /** Primary color associated with the model. */
        primaryColor?: string;
        /** Secondary color associated with the model. */
        secondaryColor?: string;
        /** SVG representation of the model in white color. */
        svgWhite: string;
        /** SVG representation of the model in colored format. */
        svgColor: string;
        /** SVG representation of the complete model. */
        svgComplete?: string;
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape?:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        [key: string]: any;
      };
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      /** The relationships of the model. */
      relationships: any;
      /** The components of the model. */
      components: any;
      /** Number of components associated with the model. */
      componentsCount: number;
      /** Number of relationships associated with the model. */
      relationshipsCount: number;
      /** Timestamp when the resource was created. */
      created_at?: string;
      /** Timestamp when the resource was updated. */
      updated_at?: string;
    };
    /** 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 */
    modelReference: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Version of the model definition. */
      version: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      registrant: {
        /** Kind of the registrant. */
        kind: string;
      };
    };
    /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
    modelId?: string;
    /** Visualization styles for a component */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
    capabilities?: {
      /** Specifies the version of the schema to which the capability definition conforms. */
      schemaVersion: string;
      /** Version of the capability definition. */
      version: string;
      /** Name of the capability in human-readible format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the capability. */
      description: string;
      /** Top-level categorization of the capability */
      kind: "action" | "mutate" | "view" | "interaction";
      /** Classification of capabilities. Used to group capabilities similar in nature. */
      type: string;
      /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
      subType: string;
      /** Key that backs the capability. */
      key: string;
      /** State of the entity in which the capability is applicable. */
      entityState: ("declaration" | "instance")[];
      /** Status of the capability */
      status: "enabled" | "disabled";
      /** Metadata contains additional information associated with the capability. Extension point. */
      metadata?: {
        [key: string]: any;
      };
    }[];
    /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
    status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
    /** Metadata contains additional information associated with the component. */
    metadata: {
      /** Genealogy represents the various representational states of the component. */
      genealogy: string;
      /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
      isAnnotation: boolean;
      /** Identifies whether the component is scoped to namespace or cluster wide. */
      isNamespaced: boolean;
      /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
      published: boolean;
      /** InstanceDetails contains information about the instance of the component. */
      instanceDetails: object;
      /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
      configurationUISchema: string;
      [key: string]: any;
    };
    /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
    configuration: object;
    /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
    component: {
      /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
      version: string;
      /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
      kind: string;
      /** JSON schema of the object as defined by the registrant. */
      schema: string;
    };
    /** Timestamp when the component was created. */
    createdAt: string;
    /** Timestamp when the component was last updated. */
    updatedAt: string;
    /** Timestamp when the component was soft-deleted. Null while the component is active. */
    deletedAt?: string;
  } & {
    /** Number of other registered entries sharing this component's kind, version, and model. */
    duplicates?: number;
  })[];
};
export type GetRegistryComponentsByCategoryAndModelApiArg = {
  /** Name of the category. */
  category: string;
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Filter components by their API version. */
  apiVersion?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
};
export type GetRegistryComponentsByCategoryAndModelAndNameApiResponse =
  /** status 200 Paginated list of matching components. */ {
    /** Current page number of the result set. */
    page?: number;
    /** Number of items in the page. */
    pageSize?: number;
    /** Total number of items available. */
    totalCount?: number;
    /** Deprecated snake_case alias of `pageSize`. */
    page_size?: number;
    /** Deprecated snake_case alias of `totalCount`. */
    total_count?: number;
  } & {
    /** The components matching the query. */
    components?: ({
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema to which the component definition conforms. */
      schemaVersion: string;
      /** Version of the component definition. */
      version: string;
      /** Name of the component in human-readable format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the component. */
      description: string;
      /** Format specifies the format used in the `component.schema` field. JSON is the default. */
      format: "JSON" | "CUE";
      /** 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 */
      model: {
        /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
        id: string;
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
        /** Version of the model definition. */
        version: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Description of the model. */
        description: string;
        /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
        status: "ignored" | "enabled" | "duplicate";
        /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
        registrant: {
          /** Connection ID */
          id: string;
          /** Connection Name */
          name: string;
          /** Associated Credential ID */
          credentialId?: string;
          /** Connection Type (platform, telemetry, collaboration) */
          type: string;
          /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
          subType: string;
          /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
          kind: string;
          /** Additional connection metadata */
          metadata?: object;
          /** Connection Status */
          status:
            | "discovered"
            | "registered"
            | "connected"
            | "ignored"
            | "maintenance"
            | "disconnected"
            | "deleted"
            | "not found";
          /** User ID who owns this connection */
          user_id?: string;
          created_at?: string;
          updated_at?: string;
          /** SQL null Timestamp to handle null values of time. */
          deleted_at?: string;
          /** Associated environments for this connection */
          environments?: {
            /** ID */
            id: string;
            /** Specifies the version of the schema to which the environment conforms. */
            schemaVersion: string;
            /** Environment name */
            name: string;
            /** Environment description */
            description: string;
            /** Environment organization ID */
            organization_id: string;
            /** Environment owner */
            owner?: string;
            /** Timestamp when the resource was created. */
            created_at?: string;
            /** Additional metadata associated with the environment. */
            metadata?: object;
            /** Timestamp when the resource was updated. */
            updated_at?: string;
            /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
            deleted_at?: string | null;
          }[];
          /** Specifies the version of the schema used for the definition. */
          schemaVersion: string;
        };
        /** ID of the registrant. */
        registrantId: string;
        /** ID of the category. */
        categoryId: string;
        /** Category of the model. */
        category: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The category of the model that determines the main grouping. */
          name:
            | "Analytics"
            | "App Definition and Development"
            | "Cloud Native Network"
            | "Cloud Native Storage"
            | "Database"
            | "Machine Learning"
            | "Observability and Analysis"
            | "Orchestration & Management"
            | "Platform"
            | "Provisioning"
            | "Runtime"
            | "Security & Compliance"
            | "Serverless"
            | "Tools"
            | "Uncategorized";
          /** Additional metadata associated with the category. */
          metadata: object;
        };
        /** Sub category of the model determines the secondary grouping. */
        subCategory:
          | "API Gateway"
          | "API Integration"
          | "Application Definition & Image Build"
          | "Automation & Configuration"
          | "Certified Kubernetes - Distribution"
          | "Chaos Engineering"
          | "Cloud Native Storage"
          | "Cloud Provider"
          | "CNI"
          | "Compute"
          | "Container Registry"
          | "Container Runtime"
          | "Container Security"
          | "Container"
          | "Content Delivery Network"
          | "Continuous Integration & Delivery"
          | "Coordination & Service Discovery"
          | "Database"
          | "Flowchart"
          | "Framework"
          | "Installable Platform"
          | "Key Management"
          | "Key Management Service"
          | "Kubernetes"
          | "Logging"
          | "Machine Learning"
          | "Management Governance"
          | "Metrics"
          | "Monitoring"
          | "Networking Content Delivery"
          | "Operating System"
          | "Query"
          | "Remote Procedure Call"
          | "Scheduling & Orchestration"
          | "Secrets Management"
          | "Security Identity & Compliance"
          | "Service Mesh"
          | "Service Proxy"
          | "Source Version Control"
          | "Storage"
          | "Specifications"
          | "Streaming & Messaging"
          | "Tools"
          | "Tracing"
          | "Uncategorized"
          | "Video Conferencing";
        /** Metadata containing additional information associated with the model. */
        metadata?: {
          /** Capabilities associated with the model */
          capabilities?: {
            /** Specifies the version of the schema to which the capability definition conforms. */
            schemaVersion: string;
            /** Version of the capability definition. */
            version: string;
            /** Name of the capability in human-readible format. */
            displayName: string;
            /** A written representation of the purpose and characteristics of the capability. */
            description: string;
            /** Top-level categorization of the capability */
            kind: "action" | "mutate" | "view" | "interaction";
            /** Classification of capabilities. Used to group capabilities similar in nature. */
            type: string;
            /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
            subType: string;
            /** Key that backs the capability. */
            key: string;
            /** State of the entity in which the capability is applicable. */
            entityState: ("declaration" | "instance")[];
            /** Status of the capability */
            status: "enabled" | "disabled";
            /** Metadata contains additional information associated with the capability. Extension point. */
            metadata?: {
              [key: string]: any;
            };
          }[];
          /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
          isAnnotation?: boolean;
          /** Primary color associated with the model. */
          primaryColor?: string;
          /** Secondary color associated with the model. */
          secondaryColor?: string;
          /** SVG representation of the model in white color. */
          svgWhite: string;
          /** SVG representation of the model in colored format. */
          svgColor: string;
          /** SVG representation of the complete model. */
          svgComplete?: string;
          /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
          shape?:
            | "ellipse"
            | "triangle"
            | "round-triangle"
            | "rectangle"
            | "round-rectangle"
            | "bottom-round-rectangle"
            | "cut-rectangle"
            | "barrel"
            | "rhomboid"
            | "diamond"
            | "round-diamond"
            | "pentagon"
            | "round-pentagon"
            | "hexagon"
            | "round-hexagon"
            | "concave-hexagon"
            | "heptagon"
            | "round-heptagon"
            | "octagon"
            | "round-octagon"
            | "star"
            | "tag"
            | "round-tag"
            | "vee"
            | "polygon";
          [key: string]: any;
        };
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        /** The relationships of the model. */
        relationships: any;
        /** The components of the model. */
        components: any;
        /** Number of components associated with the model. */
        componentsCount: number;
        /** Number of relationships associated with the model. */
        relationshipsCount: number;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
      };
      /** 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 */
      modelReference: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
      modelId?: string;
      /** Visualization styles for a component */
      styles?: {
        /** Primary color of the component used for UI representation. */
        primaryColor: string;
        /** Secondary color of the entity used for UI representation. */
        secondaryColor?: string;
        /** White SVG of the entity used for UI representation on dark background. */
        svgWhite: string;
        /** Colored SVG of the entity used for UI representation on light background. */
        svgColor: string;
        /** Complete SVG of the entity used for UI representation, often inclusive of background. */
        svgComplete: string;
        /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
        color?: string;
        /** The opacity of the label text, including its outline. */
        textOpacity?: number;
        /** A comma-separated list of font names to use on the label text. */
        fontFamily?: string;
        /** The size of the label text. */
        fontSize?: string;
        /** A CSS font style to be applied to the label text. */
        fontStyle?: string;
        /** A CSS font weight to be applied to the label text. */
        fontWeight?: string;
        /** A transformation to apply to the label text */
        textTransform?: "none" | "uppercase" | "lowercase";
        /** 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. */
        opacity?: number;
        /** 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. */
        zIndex?: number;
        /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
        label?: string;
        /** The animation to apply to the element. example ripple,bounce,etc */
        animation?: object;
        [key: string]: any;
      } & {
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
        position?: {
          /** The x-coordinate of the node. */
          x: number;
          /** The y-coordinate of the node. */
          y: number;
        };
        /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
        bodyText?: string;
        /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
        bodyTextWrap?: "none" | "wrap" | "ellipsis";
        /** The maximum width for wrapping text in the node. */
        bodyTextMaxWidth?: string;
        /** The opacity of the node's body text, including its outline. */
        bodyTextOpacity?: number;
        /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextBackgroundColor?: string;
        /** The size of the node's body text. */
        bodyTextFontSize?: number;
        /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextColor?: string;
        /** A CSS font weight to be applied to the node's body text. */
        bodyTextFontWeight?: string;
        /** A CSS horizontal alignment to be applied to the node's body text. */
        bodyTextHorizontalAlign?: string;
        /** A CSS text decoration to be applied to the node's body text. */
        bodyTextDecoration?: string;
        /** A CSS vertical alignment to be applied to the node's body text. */
        bodyTextVerticalAlign?: string;
        /** The width of the node's body or the width of an edge's line. */
        width?: number;
        /** The height of the node's body */
        height?: number;
        /** The URL that points to the image to show in the node. */
        backgroundImage?: string;
        /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
        backgroundColor?: string;
        /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
        backgroundBlacken?: number;
        /** The opacity level of the node's background colour */
        backgroundOpacity?: number;
        /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionX?: string;
        /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionY?: string;
        /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetX?: string;
        /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetY?: string;
        /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
        backgroundFit?: "none" | "contain" | "cover";
        /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
        backgroundClip?: "none" | "node" | "node-border";
        /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundWidthRelativeTo?: "none" | "inner" | "outer";
        /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundHeightRelativeTo?: "none" | "inner" | "outer";
        /** The size of the node's border. */
        borderWidth?: number;
        /** The style of the node's border */
        borderStyle?: "solid" | "dotted" | "dashed" | "double";
        /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
        borderColor?: string;
        /** The opacity of the node's border */
        borderOpacity?: number;
        /** The amount of padding around all sides of the node. */
        padding?: number;
        /** The horizontal alignment of a node's label */
        textHalign?: "left" | "center" | "right";
        /** The vertical alignment of a node's label */
        textValign?: "top" | "center" | "bottom";
        /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
        ghost?: "yes" | "no";
        /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        activeBgColor?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgOpacity?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgSize?: string;
        /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        selectionBoxColor?: string;
        /** The size of the border on the selection box. Selector needs to be *core* */
        selectionBoxBorderWidth?: number;
        /** The opacity of the selection box. Selector needs to be *core* */
        selectionBoxOpacity?: number;
        /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        outsideTextureBgColor?: string;
        /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
        outsideTextureBgOpacity?: number;
        /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
        shapePolygonPoints?: string;
        /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuBackgroundColor?: string;
        /** The opacity of the background of the component menu. */
        menuBackgroundOpacity?: number;
        /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuForgroundColor?: string;
      };
      /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
      status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
      /** Metadata contains additional information associated with the component. */
      metadata: {
        /** Genealogy represents the various representational states of the component. */
        genealogy: string;
        /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
        isAnnotation: boolean;
        /** Identifies whether the component is scoped to namespace or cluster wide. */
        isNamespaced: boolean;
        /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
        published: boolean;
        /** InstanceDetails contains information about the instance of the component. */
        instanceDetails: object;
        /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
        configurationUISchema: string;
        [key: string]: any;
      };
      /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
      configuration: object;
      /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
      component: {
        /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
        version: string;
        /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
        kind: string;
        /** JSON schema of the object as defined by the registrant. */
        schema: string;
      };
      /** Timestamp when the component was created. */
      createdAt: string;
      /** Timestamp when the component was last updated. */
      updatedAt: string;
      /** Timestamp when the component was soft-deleted. Null while the component is active. */
      deletedAt?: string;
    } & {
      /** Number of other registered entries sharing this component's kind, version, and model. */
      duplicates?: number;
    })[];
  };
export type GetRegistryComponentsByCategoryAndModelAndNameApiArg = {
  /** Name of the category. */
  category: string;
  /** Name of the model (for `DELETE /api/registry/models/{model}`, the model's ID). */
  model: string;
  /** Kind of the component (e.g. `Deployment`). */
  name: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Filter components by their API version. */
  apiVersion?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
};
export type GetRegistryComponentsByCategoryApiResponse =
  /** status 200 Paginated list of components in the category. */ {
    /** Current page number of the result set. */
    page?: number;
    /** Number of items in the page. */
    pageSize?: number;
    /** Total number of items available. */
    totalCount?: number;
    /** Deprecated snake_case alias of `pageSize`. */
    page_size?: number;
    /** Deprecated snake_case alias of `totalCount`. */
    total_count?: number;
  } & {
    /** The components matching the query. */
    components?: ({
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema to which the component definition conforms. */
      schemaVersion: string;
      /** Version of the component definition. */
      version: string;
      /** Name of the component in human-readable format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the component. */
      description: string;
      /** Format specifies the format used in the `component.schema` field. JSON is the default. */
      format: "JSON" | "CUE";
      /** 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 */
      model: {
        /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
        id: string;
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
        /** Version of the model definition. */
        version: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Description of the model. */
        description: string;
        /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
        status: "ignored" | "enabled" | "duplicate";
        /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
        registrant: {
          /** Connection ID */
          id: string;
          /** Connection Name */
          name: string;
          /** Associated Credential ID */
          credentialId?: string;
          /** Connection Type (platform, telemetry, collaboration) */
          type: string;
          /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
          subType: string;
          /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
          kind: string;
          /** Additional connection metadata */
          metadata?: object;
          /** Connection Status */
          status:
            | "discovered"
            | "registered"
            | "connected"
            | "ignored"
            | "maintenance"
            | "disconnected"
            | "deleted"
            | "not found";
          /** User ID who owns this connection */
          user_id?: string;
          created_at?: string;
          updated_at?: string;
          /** SQL null Timestamp to handle null values of time. */
          deleted_at?: string;
          /** Associated environments for this connection */
          environments?: {
            /** ID */
            id: string;
            /** Specifies the version of the schema to which the environment conforms. */
            schemaVersion: string;
            /** Environment name */
            name: string;
            /** Environment description */
            description: string;
            /** Environment organization ID */
            organization_id: string;
            /** Environment owner */
            owner?: string;
            /** Timestamp when the resource was created. */
            created_at?: string;
            /** Additional metadata associated with the environment. */
            metadata?: object;
            /** Timestamp when the resource was updated. */
            updated_at?: string;
            /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
            deleted_at?: string | null;
          }[];
          /** Specifies the version of the schema used for the definition. */
          schemaVersion: string;
        };
        /** ID of the registrant. */
        registrantId: string;
        /** ID of the category. */
        categoryId: string;
        /** Category of the model. */
        category: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The category of the model that determines the main grouping. */
          name:
            | "Analytics"
            | "App Definition and Development"
            | "Cloud Native Network"
            | "Cloud Native Storage"
            | "Database"
            | "Machine Learning"
            | "Observability and Analysis"
            | "Orchestration & Management"
            | "Platform"
            | "Provisioning"
            | "Runtime"
            | "Security & Compliance"
            | "Serverless"
            | "Tools"
            | "Uncategorized";
          /** Additional metadata associated with the category. */
          metadata: object;
        };
        /** Sub category of the model determines the secondary grouping. */
        subCategory:
          | "API Gateway"
          | "API Integration"
          | "Application Definition & Image Build"
          | "Automation & Configuration"
          | "Certified Kubernetes - Distribution"
          | "Chaos Engineering"
          | "Cloud Native Storage"
          | "Cloud Provider"
          | "CNI"
          | "Compute"
          | "Container Registry"
          | "Container Runtime"
          | "Container Security"
          | "Container"
          | "Content Delivery Network"
          | "Continuous Integration & Delivery"
          | "Coordination & Service Discovery"
          | "Database"
          | "Flowchart"
          | "Framework"
          | "Installable Platform"
          | "Key Management"
          | "Key Management Service"
          | "Kubernetes"
          | "Logging"
          | "Machine Learning"
          | "Management Governance"
          | "Metrics"
          | "Monitoring"
          | "Networking Content Delivery"
          | "Operating System"
          | "Query"
          | "Remote Procedure Call"
          | "Scheduling & Orchestration"
          | "Secrets Management"
          | "Security Identity & Compliance"
          | "Service Mesh"
          | "Service Proxy"
          | "Source Version Control"
          | "Storage"
          | "Specifications"
          | "Streaming & Messaging"
          | "Tools"
          | "Tracing"
          | "Uncategorized"
          | "Video Conferencing";
        /** Metadata containing additional information associated with the model. */
        metadata?: {
          /** Capabilities associated with the model */
          capabilities?: {
            /** Specifies the version of the schema to which the capability definition conforms. */
            schemaVersion: string;
            /** Version of the capability definition. */
            version: string;
            /** Name of the capability in human-readible format. */
            displayName: string;
            /** A written representation of the purpose and characteristics of the capability. */
            description: string;
            /** Top-level categorization of the capability */
            kind: "action" | "mutate" | "view" | "interaction";
            /** Classification of capabilities. Used to group capabilities similar in nature. */
            type: string;
            /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
            subType: string;
            /** Key that backs the capability. */
            key: string;
            /** State of the entity in which the capability is applicable. */
            entityState: ("declaration" | "instance")[];
            /** Status of the capability */
            status: "enabled" | "disabled";
            /** Metadata contains additional information associated with the capability. Extension point. */
            metadata?: {
              [key: string]: any;
            };
          }[];
          /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
          isAnnotation?: boolean;
          /** Primary color associated with the model. */
          primaryColor?: string;
          /** Secondary color associated with the model. */
          secondaryColor?: string;
          /** SVG representation of the model in white color. */
          svgWhite: string;
          /** SVG representation of the model in colored format. */
          svgColor: string;
          /** SVG representation of the complete model. */
          svgComplete?: string;
          /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
          shape?:
            | "ellipse"
            | "triangle"
            | "round-triangle"
            | "rectangle"
            | "round-rectangle"
            | "bottom-round-rectangle"
            | "cut-rectangle"
            | "barrel"
            | "rhomboid"
            | "diamond"
            | "round-diamond"
            | "pentagon"
            | "round-pentagon"
            | "hexagon"
            | "round-hexagon"
            | "concave-hexagon"
            | "heptagon"
            | "round-heptagon"
            | "octagon"
            | "round-octagon"
            | "star"
            | "tag"
            | "round-tag"
            | "vee"
            | "polygon";
          [key: string]: any;
        };
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        /** The relationships of the model. */
        relationships: any;
        /** The components of the model. */
        components: any;
        /** Number of components associated with the model. */
        componentsCount: number;
        /** Number of relationships associated with the model. */
        relationshipsCount: number;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
      };
      /** 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 */
      modelReference: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
      modelId?: string;
      /** Visualization styles for a component */
      styles?: {
        /** Primary color of the component used for UI representation. */
        primaryColor: string;
        /** Secondary color of the entity used for UI representation. */
        secondaryColor?: string;
        /** White SVG of the entity used for UI representation on dark background. */
        svgWhite: string;
        /** Colored SVG of the entity used for UI representation on light background. */
        svgColor: string;
        /** Complete SVG of the entity used for UI representation, often inclusive of background. */
        svgComplete: string;
        /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
        color?: string;
        /** The opacity of the label text, including its outline. */
        textOpacity?: number;
        /** A comma-separated list of font names to use on the label text. */
        fontFamily?: string;
        /** The size of the label text. */
        fontSize?: string;
        /** A CSS font style to be applied to the label text. */
        fontStyle?: string;
        /** A CSS font weight to be applied to the label text. */
        fontWeight?: string;
        /** A transformation to apply to the label text */
        textTransform?: "none" | "uppercase" | "lowercase";
        /** 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. */
        opacity?: number;
        /** 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. */
        zIndex?: number;
        /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
        label?: string;
        /** The animation to apply to the element. example ripple,bounce,etc */
        animation?: object;
        [key: string]: any;
      } & {
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
        position?: {
          /** The x-coordinate of the node. */
          x: number;
          /** The y-coordinate of the node. */
          y: number;
        };
        /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
        bodyText?: string;
        /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
        bodyTextWrap?: "none" | "wrap" | "ellipsis";
        /** The maximum width for wrapping text in the node. */
        bodyTextMaxWidth?: string;
        /** The opacity of the node's body text, including its outline. */
        bodyTextOpacity?: number;
        /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextBackgroundColor?: string;
        /** The size of the node's body text. */
        bodyTextFontSize?: number;
        /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextColor?: string;
        /** A CSS font weight to be applied to the node's body text. */
        bodyTextFontWeight?: string;
        /** A CSS horizontal alignment to be applied to the node's body text. */
        bodyTextHorizontalAlign?: string;
        /** A CSS text decoration to be applied to the node's body text. */
        bodyTextDecoration?: string;
        /** A CSS vertical alignment to be applied to the node's body text. */
        bodyTextVerticalAlign?: string;
        /** The width of the node's body or the width of an edge's line. */
        width?: number;
        /** The height of the node's body */
        height?: number;
        /** The URL that points to the image to show in the node. */
        backgroundImage?: string;
        /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
        backgroundColor?: string;
        /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
        backgroundBlacken?: number;
        /** The opacity level of the node's background colour */
        backgroundOpacity?: number;
        /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionX?: string;
        /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionY?: string;
        /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetX?: string;
        /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetY?: string;
        /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
        backgroundFit?: "none" | "contain" | "cover";
        /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
        backgroundClip?: "none" | "node" | "node-border";
        /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundWidthRelativeTo?: "none" | "inner" | "outer";
        /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundHeightRelativeTo?: "none" | "inner" | "outer";
        /** The size of the node's border. */
        borderWidth?: number;
        /** The style of the node's border */
        borderStyle?: "solid" | "dotted" | "dashed" | "double";
        /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
        borderColor?: string;
        /** The opacity of the node's border */
        borderOpacity?: number;
        /** The amount of padding around all sides of the node. */
        padding?: number;
        /** The horizontal alignment of a node's label */
        textHalign?: "left" | "center" | "right";
        /** The vertical alignment of a node's label */
        textValign?: "top" | "center" | "bottom";
        /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
        ghost?: "yes" | "no";
        /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        activeBgColor?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgOpacity?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgSize?: string;
        /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        selectionBoxColor?: string;
        /** The size of the border on the selection box. Selector needs to be *core* */
        selectionBoxBorderWidth?: number;
        /** The opacity of the selection box. Selector needs to be *core* */
        selectionBoxOpacity?: number;
        /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        outsideTextureBgColor?: string;
        /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
        outsideTextureBgOpacity?: number;
        /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
        shapePolygonPoints?: string;
        /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuBackgroundColor?: string;
        /** The opacity of the background of the component menu. */
        menuBackgroundOpacity?: number;
        /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuForgroundColor?: string;
      };
      /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
      status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
      /** Metadata contains additional information associated with the component. */
      metadata: {
        /** Genealogy represents the various representational states of the component. */
        genealogy: string;
        /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
        isAnnotation: boolean;
        /** Identifies whether the component is scoped to namespace or cluster wide. */
        isNamespaced: boolean;
        /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
        published: boolean;
        /** InstanceDetails contains information about the instance of the component. */
        instanceDetails: object;
        /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
        configurationUISchema: string;
        [key: string]: any;
      };
      /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
      configuration: object;
      /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
      component: {
        /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
        version: string;
        /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
        kind: string;
        /** JSON schema of the object as defined by the registrant. */
        schema: string;
      };
      /** Timestamp when the component was created. */
      createdAt: string;
      /** Timestamp when the component was last updated. */
      updatedAt: string;
      /** Timestamp when the component was soft-deleted. Null while the component is active. */
      deletedAt?: string;
    } & {
      /** Number of other registered entries sharing this component's kind, version, and model. */
      duplicates?: number;
    })[];
  };
export type GetRegistryComponentsByCategoryApiArg = {
  /** Name of the category. */
  category: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Filter components by their API version. */
  apiVersion?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
};
export type GetRegistryComponentsByCategoryAndNameApiResponse =
  /** status 200 Paginated list of matching components. */ {
    /** Current page number of the result set. */
    page?: number;
    /** Number of items in the page. */
    pageSize?: number;
    /** Total number of items available. */
    totalCount?: number;
    /** Deprecated snake_case alias of `pageSize`. */
    page_size?: number;
    /** Deprecated snake_case alias of `totalCount`. */
    total_count?: number;
  } & {
    /** The components matching the query. */
    components?: ({
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema to which the component definition conforms. */
      schemaVersion: string;
      /** Version of the component definition. */
      version: string;
      /** Name of the component in human-readable format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the component. */
      description: string;
      /** Format specifies the format used in the `component.schema` field. JSON is the default. */
      format: "JSON" | "CUE";
      /** 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 */
      model: {
        /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
        id: string;
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
        /** Version of the model definition. */
        version: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Description of the model. */
        description: string;
        /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
        status: "ignored" | "enabled" | "duplicate";
        /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
        registrant: {
          /** Connection ID */
          id: string;
          /** Connection Name */
          name: string;
          /** Associated Credential ID */
          credentialId?: string;
          /** Connection Type (platform, telemetry, collaboration) */
          type: string;
          /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
          subType: string;
          /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
          kind: string;
          /** Additional connection metadata */
          metadata?: object;
          /** Connection Status */
          status:
            | "discovered"
            | "registered"
            | "connected"
            | "ignored"
            | "maintenance"
            | "disconnected"
            | "deleted"
            | "not found";
          /** User ID who owns this connection */
          user_id?: string;
          created_at?: string;
          updated_at?: string;
          /** SQL null Timestamp to handle null values of time. */
          deleted_at?: string;
          /** Associated environments for this connection */
          environments?: {
            /** ID */
            id: string;
            /** Specifies the version of the schema to which the environment conforms. */
            schemaVersion: string;
            /** Environment name */
            name: string;
            /** Environment description */
            description: string;
            /** Environment organization ID */
            organization_id: string;
            /** Environment owner */
            owner?: string;
            /** Timestamp when the resource was created. */
            created_at?: string;
            /** Additional metadata associated with the environment. */
            metadata?: object;
            /** Timestamp when the resource was updated. */
            updated_at?: string;
            /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
            deleted_at?: string | null;
          }[];
          /** Specifies the version of the schema used for the definition. */
          schemaVersion: string;
        };
        /** ID of the registrant. */
        registrantId: string;
        /** ID of the category. */
        categoryId: string;
        /** Category of the model. */
        category: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The category of the model that determines the main grouping. */
          name:
            | "Analytics"
            | "App Definition and Development"
            | "Cloud Native Network"
            | "Cloud Native Storage"
            | "Database"
            | "Machine Learning"
            | "Observability and Analysis"
            | "Orchestration & Management"
            | "Platform"
            | "Provisioning"
            | "Runtime"
            | "Security & Compliance"
            | "Serverless"
            | "Tools"
            | "Uncategorized";
          /** Additional metadata associated with the category. */
          metadata: object;
        };
        /** Sub category of the model determines the secondary grouping. */
        subCategory:
          | "API Gateway"
          | "API Integration"
          | "Application Definition & Image Build"
          | "Automation & Configuration"
          | "Certified Kubernetes - Distribution"
          | "Chaos Engineering"
          | "Cloud Native Storage"
          | "Cloud Provider"
          | "CNI"
          | "Compute"
          | "Container Registry"
          | "Container Runtime"
          | "Container Security"
          | "Container"
          | "Content Delivery Network"
          | "Continuous Integration & Delivery"
          | "Coordination & Service Discovery"
          | "Database"
          | "Flowchart"
          | "Framework"
          | "Installable Platform"
          | "Key Management"
          | "Key Management Service"
          | "Kubernetes"
          | "Logging"
          | "Machine Learning"
          | "Management Governance"
          | "Metrics"
          | "Monitoring"
          | "Networking Content Delivery"
          | "Operating System"
          | "Query"
          | "Remote Procedure Call"
          | "Scheduling & Orchestration"
          | "Secrets Management"
          | "Security Identity & Compliance"
          | "Service Mesh"
          | "Service Proxy"
          | "Source Version Control"
          | "Storage"
          | "Specifications"
          | "Streaming & Messaging"
          | "Tools"
          | "Tracing"
          | "Uncategorized"
          | "Video Conferencing";
        /** Metadata containing additional information associated with the model. */
        metadata?: {
          /** Capabilities associated with the model */
          capabilities?: {
            /** Specifies the version of the schema to which the capability definition conforms. */
            schemaVersion: string;
            /** Version of the capability definition. */
            version: string;
            /** Name of the capability in human-readible format. */
            displayName: string;
            /** A written representation of the purpose and characteristics of the capability. */
            description: string;
            /** Top-level categorization of the capability */
            kind: "action" | "mutate" | "view" | "interaction";
            /** Classification of capabilities. Used to group capabilities similar in nature. */
            type: string;
            /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
            subType: string;
            /** Key that backs the capability. */
            key: string;
            /** State of the entity in which the capability is applicable. */
            entityState: ("declaration" | "instance")[];
            /** Status of the capability */
            status: "enabled" | "disabled";
            /** Metadata contains additional information associated with the capability. Extension point. */
            metadata?: {
              [key: string]: any;
            };
          }[];
          /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
          isAnnotation?: boolean;
          /** Primary color associated with the model. */
          primaryColor?: string;
          /** Secondary color associated with the model. */
          secondaryColor?: string;
          /** SVG representation of the model in white color. */
          svgWhite: string;
          /** SVG representation of the model in colored format. */
          svgColor: string;
          /** SVG representation of the complete model. */
          svgComplete?: string;
          /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
          shape?:
            | "ellipse"
            | "triangle"
            | "round-triangle"
            | "rectangle"
            | "round-rectangle"
            | "bottom-round-rectangle"
            | "cut-rectangle"
            | "barrel"
            | "rhomboid"
            | "diamond"
            | "round-diamond"
            | "pentagon"
            | "round-pentagon"
            | "hexagon"
            | "round-hexagon"
            | "concave-hexagon"
            | "heptagon"
            | "round-heptagon"
            | "octagon"
            | "round-octagon"
            | "star"
            | "tag"
            | "round-tag"
            | "vee"
            | "polygon";
          [key: string]: any;
        };
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        /** The relationships of the model. */
        relationships: any;
        /** The components of the model. */
        components: any;
        /** Number of components associated with the model. */
        componentsCount: number;
        /** Number of relationships associated with the model. */
        relationshipsCount: number;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
      };
      /** 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 */
      modelReference: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
      modelId?: string;
      /** Visualization styles for a component */
      styles?: {
        /** Primary color of the component used for UI representation. */
        primaryColor: string;
        /** Secondary color of the entity used for UI representation. */
        secondaryColor?: string;
        /** White SVG of the entity used for UI representation on dark background. */
        svgWhite: string;
        /** Colored SVG of the entity used for UI representation on light background. */
        svgColor: string;
        /** Complete SVG of the entity used for UI representation, often inclusive of background. */
        svgComplete: string;
        /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
        color?: string;
        /** The opacity of the label text, including its outline. */
        textOpacity?: number;
        /** A comma-separated list of font names to use on the label text. */
        fontFamily?: string;
        /** The size of the label text. */
        fontSize?: string;
        /** A CSS font style to be applied to the label text. */
        fontStyle?: string;
        /** A CSS font weight to be applied to the label text. */
        fontWeight?: string;
        /** A transformation to apply to the label text */
        textTransform?: "none" | "uppercase" | "lowercase";
        /** 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. */
        opacity?: number;
        /** 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. */
        zIndex?: number;
        /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
        label?: string;
        /** The animation to apply to the element. example ripple,bounce,etc */
        animation?: object;
        [key: string]: any;
      } & {
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
        position?: {
          /** The x-coordinate of the node. */
          x: number;
          /** The y-coordinate of the node. */
          y: number;
        };
        /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
        bodyText?: string;
        /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
        bodyTextWrap?: "none" | "wrap" | "ellipsis";
        /** The maximum width for wrapping text in the node. */
        bodyTextMaxWidth?: string;
        /** The opacity of the node's body text, including its outline. */
        bodyTextOpacity?: number;
        /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextBackgroundColor?: string;
        /** The size of the node's body text. */
        bodyTextFontSize?: number;
        /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextColor?: string;
        /** A CSS font weight to be applied to the node's body text. */
        bodyTextFontWeight?: string;
        /** A CSS horizontal alignment to be applied to the node's body text. */
        bodyTextHorizontalAlign?: string;
        /** A CSS text decoration to be applied to the node's body text. */
        bodyTextDecoration?: string;
        /** A CSS vertical alignment to be applied to the node's body text. */
        bodyTextVerticalAlign?: string;
        /** The width of the node's body or the width of an edge's line. */
        width?: number;
        /** The height of the node's body */
        height?: number;
        /** The URL that points to the image to show in the node. */
        backgroundImage?: string;
        /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
        backgroundColor?: string;
        /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
        backgroundBlacken?: number;
        /** The opacity level of the node's background colour */
        backgroundOpacity?: number;
        /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionX?: string;
        /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionY?: string;
        /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetX?: string;
        /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetY?: string;
        /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
        backgroundFit?: "none" | "contain" | "cover";
        /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
        backgroundClip?: "none" | "node" | "node-border";
        /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundWidthRelativeTo?: "none" | "inner" | "outer";
        /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundHeightRelativeTo?: "none" | "inner" | "outer";
        /** The size of the node's border. */
        borderWidth?: number;
        /** The style of the node's border */
        borderStyle?: "solid" | "dotted" | "dashed" | "double";
        /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
        borderColor?: string;
        /** The opacity of the node's border */
        borderOpacity?: number;
        /** The amount of padding around all sides of the node. */
        padding?: number;
        /** The horizontal alignment of a node's label */
        textHalign?: "left" | "center" | "right";
        /** The vertical alignment of a node's label */
        textValign?: "top" | "center" | "bottom";
        /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
        ghost?: "yes" | "no";
        /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        activeBgColor?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgOpacity?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgSize?: string;
        /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        selectionBoxColor?: string;
        /** The size of the border on the selection box. Selector needs to be *core* */
        selectionBoxBorderWidth?: number;
        /** The opacity of the selection box. Selector needs to be *core* */
        selectionBoxOpacity?: number;
        /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        outsideTextureBgColor?: string;
        /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
        outsideTextureBgOpacity?: number;
        /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
        shapePolygonPoints?: string;
        /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuBackgroundColor?: string;
        /** The opacity of the background of the component menu. */
        menuBackgroundOpacity?: number;
        /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuForgroundColor?: string;
      };
      /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
      status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
      /** Metadata contains additional information associated with the component. */
      metadata: {
        /** Genealogy represents the various representational states of the component. */
        genealogy: string;
        /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
        isAnnotation: boolean;
        /** Identifies whether the component is scoped to namespace or cluster wide. */
        isNamespaced: boolean;
        /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
        published: boolean;
        /** InstanceDetails contains information about the instance of the component. */
        instanceDetails: object;
        /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
        configurationUISchema: string;
        [key: string]: any;
      };
      /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
      configuration: object;
      /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
      component: {
        /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
        version: string;
        /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
        kind: string;
        /** JSON schema of the object as defined by the registrant. */
        schema: string;
      };
      /** Timestamp when the component was created. */
      createdAt: string;
      /** Timestamp when the component was last updated. */
      updatedAt: string;
      /** Timestamp when the component was soft-deleted. Null while the component is active. */
      deletedAt?: string;
    } & {
      /** Number of other registered entries sharing this component's kind, version, and model. */
      duplicates?: number;
    })[];
  };
export type GetRegistryComponentsByCategoryAndNameApiArg = {
  /** Name of the category. */
  category: string;
  /** Kind of the component (e.g. `Deployment`). */
  name: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Filter components by their API version. */
  apiVersion?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
};
export type GetRegistryComponentsApiResponse = /** status 200 Paginated list of registered components. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The components matching the query. */
  components?: ({
    /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
    id: string;
    /** Specifies the version of the schema to which the component definition conforms. */
    schemaVersion: string;
    /** Version of the component definition. */
    version: string;
    /** Name of the component in human-readable format. */
    displayName: string;
    /** A written representation of the purpose and characteristics of the component. */
    description: string;
    /** Format specifies the format used in the `component.schema` field. JSON is the default. */
    format: "JSON" | "CUE";
    /** 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 */
    model: {
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
      /** Version of the model definition. */
      version: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Description of the model. */
      description: string;
      /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
      status: "ignored" | "enabled" | "duplicate";
      /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
      registrant: {
        /** Connection ID */
        id: string;
        /** Connection Name */
        name: string;
        /** Associated Credential ID */
        credentialId?: string;
        /** Connection Type (platform, telemetry, collaboration) */
        type: string;
        /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
        subType: string;
        /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
        kind: string;
        /** Additional connection metadata */
        metadata?: object;
        /** Connection Status */
        status:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** User ID who owns this connection */
        user_id?: string;
        created_at?: string;
        updated_at?: string;
        /** SQL null Timestamp to handle null values of time. */
        deleted_at?: string;
        /** Associated environments for this connection */
        environments?: {
          /** ID */
          id: string;
          /** Specifies the version of the schema to which the environment conforms. */
          schemaVersion: string;
          /** Environment name */
          name: string;
          /** Environment description */
          description: string;
          /** Environment organization ID */
          organization_id: string;
          /** Environment owner */
          owner?: string;
          /** Timestamp when the resource was created. */
          created_at?: string;
          /** Additional metadata associated with the environment. */
          metadata?: object;
          /** Timestamp when the resource was updated. */
          updated_at?: string;
          /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
          deleted_at?: string | null;
        }[];
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
      };
      /** ID of the registrant. */
      registrantId: string;
      /** ID of the category. */
      categoryId: string;
      /** Category of the model. */
      category: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The category of the model that determines the main grouping. */
        name:
          | "Analytics"
          | "App Definition and Development"
          | "Cloud Native Network"
          | "Cloud Native Storage"
          | "Database"
          | "Machine Learning"
          | "Observability and Analysis"
          | "Orchestration & Management"
          | "Platform"
          | "Provisioning"
          | "Runtime"
          | "Security & Compliance"
          | "Serverless"
          | "Tools"
          | "Uncategorized";
        /** Additional metadata associated with the category. */
        metadata: object;
      };
      /** Sub category of the model determines the secondary grouping. */
      subCategory:
        | "API Gateway"
        | "API Integration"
        | "Application Definition & Image Build"
        | "Automation & Configuration"
        | "Certified Kubernetes - Distribution"
        | "Chaos Engineering"
        | "Cloud Native Storage"
        | "Cloud Provider"
        | "CNI"
        | "Compute"
        | "Container Registry"
        | "Container Runtime"
        | "Container Security"
        | "Container"
        | "Content Delivery Network"
        | "Continuous Integration & Delivery"
        | "Coordination & Service Discovery"
        | "Database"
        | "Flowchart"
        | "Framework"
        | "Installable Platform"
        | "Key Management"
        | "Key Management Service"
        | "Kubernetes"
        | "Logging"
        | "Machine Learning"
        | "Management Governance"
        | "Metrics"
        | "Monitoring"
        | "Networking Content Delivery"
        | "Operating System"
        | "Query"
        | "Remote Procedure Call"
        | "Scheduling & Orchestration"
        | "Secrets Management"
        | "Security Identity & Compliance"
        | "Service Mesh"
        | "Service Proxy"
        | "Source Version Control"
        | "Storage"
        | "Specifications"
        | "Streaming & Messaging"
        | "Tools"
        | "Tracing"
        | "Uncategorized"
        | "Video Conferencing";
      /** Metadata containing additional information associated with the model. */
      metadata?: {
        /** Capabilities associated with the model */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
        isAnnotation?: boolean;
        /** Primary color associated with the model. */
        primaryColor?: string;
        /** Secondary color associated with the model. */
        secondaryColor?: string;
        /** SVG representation of the model in white color. */
        svgWhite: string;
        /** SVG representation of the model in colored format. */
        svgColor: string;
        /** SVG representation of the complete model. */
        svgComplete?: string;
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape?:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        [key: string]: any;
      };
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      /** The relationships of the model. */
      relationships: any;
      /** The components of the model. */
      components: any;
      /** Number of components associated with the model. */
      componentsCount: number;
      /** Number of relationships associated with the model. */
      relationshipsCount: number;
      /** Timestamp when the resource was created. */
      created_at?: string;
      /** Timestamp when the resource was updated. */
      updated_at?: string;
    };
    /** 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 */
    modelReference: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Version of the model definition. */
      version: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      registrant: {
        /** Kind of the registrant. */
        kind: string;
      };
    };
    /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
    modelId?: string;
    /** Visualization styles for a component */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
    capabilities?: {
      /** Specifies the version of the schema to which the capability definition conforms. */
      schemaVersion: string;
      /** Version of the capability definition. */
      version: string;
      /** Name of the capability in human-readible format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the capability. */
      description: string;
      /** Top-level categorization of the capability */
      kind: "action" | "mutate" | "view" | "interaction";
      /** Classification of capabilities. Used to group capabilities similar in nature. */
      type: string;
      /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
      subType: string;
      /** Key that backs the capability. */
      key: string;
      /** State of the entity in which the capability is applicable. */
      entityState: ("declaration" | "instance")[];
      /** Status of the capability */
      status: "enabled" | "disabled";
      /** Metadata contains additional information associated with the capability. Extension point. */
      metadata?: {
        [key: string]: any;
      };
    }[];
    /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
    status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
    /** Metadata contains additional information associated with the component. */
    metadata: {
      /** Genealogy represents the various representational states of the component. */
      genealogy: string;
      /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
      isAnnotation: boolean;
      /** Identifies whether the component is scoped to namespace or cluster wide. */
      isNamespaced: boolean;
      /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
      published: boolean;
      /** InstanceDetails contains information about the instance of the component. */
      instanceDetails: object;
      /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
      configurationUISchema: string;
      [key: string]: any;
    };
    /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
    configuration: object;
    /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
    component: {
      /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
      version: string;
      /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
      kind: string;
      /** JSON schema of the object as defined by the registrant. */
      schema: string;
    };
    /** Timestamp when the component was created. */
    createdAt: string;
    /** Timestamp when the component was last updated. */
    updatedAt: string;
    /** Timestamp when the component was soft-deleted. Null while the component is active. */
    deletedAt?: string;
  } & {
    /** Number of other registered entries sharing this component's kind, version, and model. */
    duplicates?: number;
  })[];
};
export type GetRegistryComponentsApiArg = {
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Filter components by their API version. */
  apiVersion?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
};
export type RegisterRegistryComponentApiResponse = unknown;
export type RegisterRegistryComponentApiArg = {
  body: {
    /** Connection identifying the registrant. */
    connection: {
      /** Connection ID */
      id: string;
      /** Connection Name */
      name: string;
      /** Human-readable description of the connection and its purpose. */
      description?: string;
      /** URL of the remote resource this connection points to (e.g. the Helm repository URL, the Kubernetes API server endpoint, the Grafana instance URL). */
      url?: string;
      /** Associated Credential ID */
      credentialId?: string;
      /** Connection Type (platform, telemetry, collaboration) */
      type: string;
      /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
      subType: string;
      /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
      kind: string;
      /** 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 */
      modelReference?: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** Additional connection metadata */
      metadata?: object;
      /** Schema for the credential Associated with the connection */
      credentialSchema?: object;
      /** Schema for the connection */
      connectionSchema?: object;
      /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
      styles?: {
        /** Primary color of the component used for UI representation. */
        primaryColor: string;
        /** Secondary color of the entity used for UI representation. */
        secondaryColor?: string;
        /** White SVG of the entity used for UI representation on dark background. */
        svgWhite: string;
        /** Colored SVG of the entity used for UI representation on light background. */
        svgColor: string;
        /** Complete SVG of the entity used for UI representation, often inclusive of background. */
        svgComplete: string;
        /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
        color?: string;
        /** The opacity of the label text, including its outline. */
        textOpacity?: number;
        /** A comma-separated list of font names to use on the label text. */
        fontFamily?: string;
        /** The size of the label text. */
        fontSize?: string;
        /** A CSS font style to be applied to the label text. */
        fontStyle?: string;
        /** A CSS font weight to be applied to the label text. */
        fontWeight?: string;
        /** A transformation to apply to the label text */
        textTransform?: "none" | "uppercase" | "lowercase";
        /** 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. */
        opacity?: number;
        /** 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. */
        zIndex?: number;
        /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
        label?: string;
        /** The animation to apply to the element. example ripple,bounce,etc */
        animation?: object;
        [key: string]: any;
      } & {
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
        position?: {
          /** The x-coordinate of the node. */
          x: number;
          /** The y-coordinate of the node. */
          y: number;
        };
        /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
        bodyText?: string;
        /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
        bodyTextWrap?: "none" | "wrap" | "ellipsis";
        /** The maximum width for wrapping text in the node. */
        bodyTextMaxWidth?: string;
        /** The opacity of the node's body text, including its outline. */
        bodyTextOpacity?: number;
        /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextBackgroundColor?: string;
        /** The size of the node's body text. */
        bodyTextFontSize?: number;
        /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextColor?: string;
        /** A CSS font weight to be applied to the node's body text. */
        bodyTextFontWeight?: string;
        /** A CSS horizontal alignment to be applied to the node's body text. */
        bodyTextHorizontalAlign?: string;
        /** A CSS text decoration to be applied to the node's body text. */
        bodyTextDecoration?: string;
        /** A CSS vertical alignment to be applied to the node's body text. */
        bodyTextVerticalAlign?: string;
        /** The width of the node's body or the width of an edge's line. */
        width?: number;
        /** The height of the node's body */
        height?: number;
        /** The URL that points to the image to show in the node. */
        backgroundImage?: string;
        /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
        backgroundColor?: string;
        /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
        backgroundBlacken?: number;
        /** The opacity level of the node's background colour */
        backgroundOpacity?: number;
        /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionX?: string;
        /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionY?: string;
        /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetX?: string;
        /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetY?: string;
        /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
        backgroundFit?: "none" | "contain" | "cover";
        /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
        backgroundClip?: "none" | "node" | "node-border";
        /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundWidthRelativeTo?: "none" | "inner" | "outer";
        /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundHeightRelativeTo?: "none" | "inner" | "outer";
        /** The size of the node's border. */
        borderWidth?: number;
        /** The style of the node's border */
        borderStyle?: "solid" | "dotted" | "dashed" | "double";
        /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
        borderColor?: string;
        /** The opacity of the node's border */
        borderOpacity?: number;
        /** The amount of padding around all sides of the node. */
        padding?: number;
        /** The horizontal alignment of a node's label */
        textHalign?: "left" | "center" | "right";
        /** The vertical alignment of a node's label */
        textValign?: "top" | "center" | "bottom";
        /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
        ghost?: "yes" | "no";
        /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        activeBgColor?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgOpacity?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgSize?: string;
        /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        selectionBoxColor?: string;
        /** The size of the border on the selection box. Selector needs to be *core* */
        selectionBoxBorderWidth?: number;
        /** The opacity of the selection box. Selector needs to be *core* */
        selectionBoxOpacity?: number;
        /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        outsideTextureBgColor?: string;
        /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
        outsideTextureBgOpacity?: number;
        /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
        shapePolygonPoints?: string;
        /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuBackgroundColor?: string;
        /** The opacity of the background of the component menu. */
        menuBackgroundOpacity?: number;
        /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuForgroundColor?: string;
      };
      /** Connection Status */
      status:
        | "discovered"
        | "registered"
        | "connected"
        | "ignored"
        | "maintenance"
        | "disconnected"
        | "deleted"
        | "not found";
      /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status, along with a description of each transition. */
      transitionMap?: {
        [key: string]: {
          /** The connection state reachable from the current state. */
          nextState:
            | "discovered"
            | "registered"
            | "connected"
            | "ignored"
            | "maintenance"
            | "disconnected"
            | "deleted"
            | "not found";
          /** Human-readable explanation of when or why this transition occurs. */
          description?: string;
        }[];
      };
      /** User ID who owns this connection */
      owner?: string;
      /** Timestamp when the connection was created. */
      createdAt?: string;
      /** Timestamp when the connection was last updated. */
      updatedAt?: string;
      /** Timestamp when the connection was soft-deleted, if applicable. */
      deletedAt?: string | null;
      /** Associated environments for this connection */
      environments?: {
        /** ID */
        id: string;
        /** Specifies the version of the schema to which the environment conforms. */
        schemaVersion: string;
        /** Environment name */
        name: string;
        /** Environment description */
        description: string;
        /** Environment organization ID */
        organizationId: string;
        /** Environment owner */
        owner?: string;
        /** Timestamp when the environment was created. */
        createdAt?: string;
        /** Additional metadata associated with the environment. */
        metadata?: object;
        /** Timestamp when the environment was last updated. */
        updatedAt?: string;
        /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
        deletedAt?: string | null;
      }[];
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
    };
    /** Type of the entity being registered (e.g. `component`, `relationship`). */
    entityType: string;
    /** Base64-encoded JSON definition of the entity being registered. */
    entity: string;
  };
};
export type GetRegistryComponentsByNameApiResponse = /** status 200 Paginated list of matching components. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The components matching the query. */
  components?: ({
    /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
    id: string;
    /** Specifies the version of the schema to which the component definition conforms. */
    schemaVersion: string;
    /** Version of the component definition. */
    version: string;
    /** Name of the component in human-readable format. */
    displayName: string;
    /** A written representation of the purpose and characteristics of the component. */
    description: string;
    /** Format specifies the format used in the `component.schema` field. JSON is the default. */
    format: "JSON" | "CUE";
    /** 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 */
    model: {
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
      /** Version of the model definition. */
      version: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Description of the model. */
      description: string;
      /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
      status: "ignored" | "enabled" | "duplicate";
      /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
      registrant: {
        /** Connection ID */
        id: string;
        /** Connection Name */
        name: string;
        /** Associated Credential ID */
        credentialId?: string;
        /** Connection Type (platform, telemetry, collaboration) */
        type: string;
        /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
        subType: string;
        /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
        kind: string;
        /** Additional connection metadata */
        metadata?: object;
        /** Connection Status */
        status:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** User ID who owns this connection */
        user_id?: string;
        created_at?: string;
        updated_at?: string;
        /** SQL null Timestamp to handle null values of time. */
        deleted_at?: string;
        /** Associated environments for this connection */
        environments?: {
          /** ID */
          id: string;
          /** Specifies the version of the schema to which the environment conforms. */
          schemaVersion: string;
          /** Environment name */
          name: string;
          /** Environment description */
          description: string;
          /** Environment organization ID */
          organization_id: string;
          /** Environment owner */
          owner?: string;
          /** Timestamp when the resource was created. */
          created_at?: string;
          /** Additional metadata associated with the environment. */
          metadata?: object;
          /** Timestamp when the resource was updated. */
          updated_at?: string;
          /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
          deleted_at?: string | null;
        }[];
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
      };
      /** ID of the registrant. */
      registrantId: string;
      /** ID of the category. */
      categoryId: string;
      /** Category of the model. */
      category: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The category of the model that determines the main grouping. */
        name:
          | "Analytics"
          | "App Definition and Development"
          | "Cloud Native Network"
          | "Cloud Native Storage"
          | "Database"
          | "Machine Learning"
          | "Observability and Analysis"
          | "Orchestration & Management"
          | "Platform"
          | "Provisioning"
          | "Runtime"
          | "Security & Compliance"
          | "Serverless"
          | "Tools"
          | "Uncategorized";
        /** Additional metadata associated with the category. */
        metadata: object;
      };
      /** Sub category of the model determines the secondary grouping. */
      subCategory:
        | "API Gateway"
        | "API Integration"
        | "Application Definition & Image Build"
        | "Automation & Configuration"
        | "Certified Kubernetes - Distribution"
        | "Chaos Engineering"
        | "Cloud Native Storage"
        | "Cloud Provider"
        | "CNI"
        | "Compute"
        | "Container Registry"
        | "Container Runtime"
        | "Container Security"
        | "Container"
        | "Content Delivery Network"
        | "Continuous Integration & Delivery"
        | "Coordination & Service Discovery"
        | "Database"
        | "Flowchart"
        | "Framework"
        | "Installable Platform"
        | "Key Management"
        | "Key Management Service"
        | "Kubernetes"
        | "Logging"
        | "Machine Learning"
        | "Management Governance"
        | "Metrics"
        | "Monitoring"
        | "Networking Content Delivery"
        | "Operating System"
        | "Query"
        | "Remote Procedure Call"
        | "Scheduling & Orchestration"
        | "Secrets Management"
        | "Security Identity & Compliance"
        | "Service Mesh"
        | "Service Proxy"
        | "Source Version Control"
        | "Storage"
        | "Specifications"
        | "Streaming & Messaging"
        | "Tools"
        | "Tracing"
        | "Uncategorized"
        | "Video Conferencing";
      /** Metadata containing additional information associated with the model. */
      metadata?: {
        /** Capabilities associated with the model */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
        isAnnotation?: boolean;
        /** Primary color associated with the model. */
        primaryColor?: string;
        /** Secondary color associated with the model. */
        secondaryColor?: string;
        /** SVG representation of the model in white color. */
        svgWhite: string;
        /** SVG representation of the model in colored format. */
        svgColor: string;
        /** SVG representation of the complete model. */
        svgComplete?: string;
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape?:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        [key: string]: any;
      };
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      /** The relationships of the model. */
      relationships: any;
      /** The components of the model. */
      components: any;
      /** Number of components associated with the model. */
      componentsCount: number;
      /** Number of relationships associated with the model. */
      relationshipsCount: number;
      /** Timestamp when the resource was created. */
      created_at?: string;
      /** Timestamp when the resource was updated. */
      updated_at?: string;
    };
    /** 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 */
    modelReference: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Version of the model definition. */
      version: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      registrant: {
        /** Kind of the registrant. */
        kind: string;
      };
    };
    /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
    modelId?: string;
    /** Visualization styles for a component */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
    capabilities?: {
      /** Specifies the version of the schema to which the capability definition conforms. */
      schemaVersion: string;
      /** Version of the capability definition. */
      version: string;
      /** Name of the capability in human-readible format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the capability. */
      description: string;
      /** Top-level categorization of the capability */
      kind: "action" | "mutate" | "view" | "interaction";
      /** Classification of capabilities. Used to group capabilities similar in nature. */
      type: string;
      /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
      subType: string;
      /** Key that backs the capability. */
      key: string;
      /** State of the entity in which the capability is applicable. */
      entityState: ("declaration" | "instance")[];
      /** Status of the capability */
      status: "enabled" | "disabled";
      /** Metadata contains additional information associated with the capability. Extension point. */
      metadata?: {
        [key: string]: any;
      };
    }[];
    /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
    status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
    /** Metadata contains additional information associated with the component. */
    metadata: {
      /** Genealogy represents the various representational states of the component. */
      genealogy: string;
      /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
      isAnnotation: boolean;
      /** Identifies whether the component is scoped to namespace or cluster wide. */
      isNamespaced: boolean;
      /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
      published: boolean;
      /** InstanceDetails contains information about the instance of the component. */
      instanceDetails: object;
      /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
      configurationUISchema: string;
      [key: string]: any;
    };
    /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
    configuration: object;
    /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
    component: {
      /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
      version: string;
      /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
      kind: string;
      /** JSON schema of the object as defined by the registrant. */
      schema: string;
    };
    /** Timestamp when the component was created. */
    createdAt: string;
    /** Timestamp when the component was last updated. */
    updatedAt: string;
    /** Timestamp when the component was soft-deleted. Null while the component is active. */
    deletedAt?: string;
  } & {
    /** Number of other registered entries sharing this component's kind, version, and model. */
    duplicates?: number;
  })[];
};
export type GetRegistryComponentsByNameApiArg = {
  /** Kind of the component (e.g. `Deployment`). */
  name: string;
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** When `true`, the component name is matched greedily (substring match). */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
  /** Filter components by their API version. */
  apiVersion?: string;
  /** When `true`, omits large schema payloads from the returned definitions. */
  trim?: string;
  /** Annotation filter: `true` returns only annotation entities, `false` excludes them, and `include` returns both. */
  annotations?: string;
};
export type GetRegistryRelationshipsApiResponse = /** status 200 Paginated list of registered relationships. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The relationships matching the query. */
  relationships?: any[];
};
export type GetRegistryRelationshipsApiArg = {
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
  /** Filter by model version. */
  version?: string;
};
export type RegisterRegistryRelationshipApiResponse = unknown;
export type RegisterRegistryRelationshipApiArg = {
  body: {
    /** Connection identifying the registrant. */
    connection: {
      /** Connection ID */
      id: string;
      /** Connection Name */
      name: string;
      /** Human-readable description of the connection and its purpose. */
      description?: string;
      /** URL of the remote resource this connection points to (e.g. the Helm repository URL, the Kubernetes API server endpoint, the Grafana instance URL). */
      url?: string;
      /** Associated Credential ID */
      credentialId?: string;
      /** Connection Type (platform, telemetry, collaboration) */
      type: string;
      /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
      subType: string;
      /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
      kind: string;
      /** 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 */
      modelReference?: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** Additional connection metadata */
      metadata?: object;
      /** Schema for the credential Associated with the connection */
      credentialSchema?: object;
      /** Schema for the connection */
      connectionSchema?: object;
      /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
      styles?: {
        /** Primary color of the component used for UI representation. */
        primaryColor: string;
        /** Secondary color of the entity used for UI representation. */
        secondaryColor?: string;
        /** White SVG of the entity used for UI representation on dark background. */
        svgWhite: string;
        /** Colored SVG of the entity used for UI representation on light background. */
        svgColor: string;
        /** Complete SVG of the entity used for UI representation, often inclusive of background. */
        svgComplete: string;
        /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
        color?: string;
        /** The opacity of the label text, including its outline. */
        textOpacity?: number;
        /** A comma-separated list of font names to use on the label text. */
        fontFamily?: string;
        /** The size of the label text. */
        fontSize?: string;
        /** A CSS font style to be applied to the label text. */
        fontStyle?: string;
        /** A CSS font weight to be applied to the label text. */
        fontWeight?: string;
        /** A transformation to apply to the label text */
        textTransform?: "none" | "uppercase" | "lowercase";
        /** 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. */
        opacity?: number;
        /** 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. */
        zIndex?: number;
        /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
        label?: string;
        /** The animation to apply to the element. example ripple,bounce,etc */
        animation?: object;
        [key: string]: any;
      } & {
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
        position?: {
          /** The x-coordinate of the node. */
          x: number;
          /** The y-coordinate of the node. */
          y: number;
        };
        /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
        bodyText?: string;
        /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
        bodyTextWrap?: "none" | "wrap" | "ellipsis";
        /** The maximum width for wrapping text in the node. */
        bodyTextMaxWidth?: string;
        /** The opacity of the node's body text, including its outline. */
        bodyTextOpacity?: number;
        /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextBackgroundColor?: string;
        /** The size of the node's body text. */
        bodyTextFontSize?: number;
        /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextColor?: string;
        /** A CSS font weight to be applied to the node's body text. */
        bodyTextFontWeight?: string;
        /** A CSS horizontal alignment to be applied to the node's body text. */
        bodyTextHorizontalAlign?: string;
        /** A CSS text decoration to be applied to the node's body text. */
        bodyTextDecoration?: string;
        /** A CSS vertical alignment to be applied to the node's body text. */
        bodyTextVerticalAlign?: string;
        /** The width of the node's body or the width of an edge's line. */
        width?: number;
        /** The height of the node's body */
        height?: number;
        /** The URL that points to the image to show in the node. */
        backgroundImage?: string;
        /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
        backgroundColor?: string;
        /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
        backgroundBlacken?: number;
        /** The opacity level of the node's background colour */
        backgroundOpacity?: number;
        /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionX?: string;
        /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionY?: string;
        /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetX?: string;
        /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetY?: string;
        /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
        backgroundFit?: "none" | "contain" | "cover";
        /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
        backgroundClip?: "none" | "node" | "node-border";
        /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundWidthRelativeTo?: "none" | "inner" | "outer";
        /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundHeightRelativeTo?: "none" | "inner" | "outer";
        /** The size of the node's border. */
        borderWidth?: number;
        /** The style of the node's border */
        borderStyle?: "solid" | "dotted" | "dashed" | "double";
        /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
        borderColor?: string;
        /** The opacity of the node's border */
        borderOpacity?: number;
        /** The amount of padding around all sides of the node. */
        padding?: number;
        /** The horizontal alignment of a node's label */
        textHalign?: "left" | "center" | "right";
        /** The vertical alignment of a node's label */
        textValign?: "top" | "center" | "bottom";
        /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
        ghost?: "yes" | "no";
        /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        activeBgColor?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgOpacity?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgSize?: string;
        /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        selectionBoxColor?: string;
        /** The size of the border on the selection box. Selector needs to be *core* */
        selectionBoxBorderWidth?: number;
        /** The opacity of the selection box. Selector needs to be *core* */
        selectionBoxOpacity?: number;
        /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        outsideTextureBgColor?: string;
        /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
        outsideTextureBgOpacity?: number;
        /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
        shapePolygonPoints?: string;
        /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuBackgroundColor?: string;
        /** The opacity of the background of the component menu. */
        menuBackgroundOpacity?: number;
        /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuForgroundColor?: string;
      };
      /** Connection Status */
      status:
        | "discovered"
        | "registered"
        | "connected"
        | "ignored"
        | "maintenance"
        | "disconnected"
        | "deleted"
        | "not found";
      /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status, along with a description of each transition. */
      transitionMap?: {
        [key: string]: {
          /** The connection state reachable from the current state. */
          nextState:
            | "discovered"
            | "registered"
            | "connected"
            | "ignored"
            | "maintenance"
            | "disconnected"
            | "deleted"
            | "not found";
          /** Human-readable explanation of when or why this transition occurs. */
          description?: string;
        }[];
      };
      /** User ID who owns this connection */
      owner?: string;
      /** Timestamp when the connection was created. */
      createdAt?: string;
      /** Timestamp when the connection was last updated. */
      updatedAt?: string;
      /** Timestamp when the connection was soft-deleted, if applicable. */
      deletedAt?: string | null;
      /** Associated environments for this connection */
      environments?: {
        /** ID */
        id: string;
        /** Specifies the version of the schema to which the environment conforms. */
        schemaVersion: string;
        /** Environment name */
        name: string;
        /** Environment description */
        description: string;
        /** Environment organization ID */
        organizationId: string;
        /** Environment owner */
        owner?: string;
        /** Timestamp when the environment was created. */
        createdAt?: string;
        /** Additional metadata associated with the environment. */
        metadata?: object;
        /** Timestamp when the environment was last updated. */
        updatedAt?: string;
        /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
        deletedAt?: string | null;
      }[];
      /** Specifies the version of the schema used for the definition. */
      schemaVersion: string;
    };
    /** Type of the entity being registered (e.g. `component`, `relationship`). */
    entityType: string;
    /** Base64-encoded JSON definition of the entity being registered. */
    entity: string;
  };
};
export type GetRegistryRegistrantsApiResponse = /** status 200 Paginated list of registrants. */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items in the page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** Deprecated snake_case alias of `pageSize`. */
  page_size?: number;
  /** Deprecated snake_case alias of `totalCount`. */
  total_count?: number;
} & {
  /** The registrants matching the query. */
  registrants?: ({
    /** Connection ID */
    id: string;
    /** Connection Name */
    name: string;
    /** Associated Credential ID */
    credentialId?: string;
    /** Connection Type (platform, telemetry, collaboration) */
    type: string;
    /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
    subType: string;
    /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
    kind: string;
    /** Additional connection metadata */
    metadata?: object;
    /** Connection Status */
    status:
      | "discovered"
      | "registered"
      | "connected"
      | "ignored"
      | "maintenance"
      | "disconnected"
      | "deleted"
      | "not found";
    /** User ID who owns this connection */
    user_id?: string;
    created_at?: string;
    updated_at?: string;
    /** SQL null Timestamp to handle null values of time. */
    deleted_at?: string;
    /** Associated environments for this connection */
    environments?: {
      /** ID */
      id: string;
      /** Specifies the version of the schema to which the environment conforms. */
      schemaVersion: string;
      /** Environment name */
      name: string;
      /** Environment description */
      description: string;
      /** Environment organization ID */
      organization_id: string;
      /** Environment owner */
      owner?: string;
      /** Timestamp when the resource was created. */
      created_at?: string;
      /** Additional metadata associated with the environment. */
      metadata?: object;
      /** Timestamp when the resource was updated. */
      updated_at?: string;
      /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
      deleted_at?: string | null;
    }[];
    /** Specifies the version of the schema used for the definition. */
    schemaVersion: string;
  } & {
    /** Counts of the entities a registrant has registered. */
    summary?: {
      /** Number of models registered by this registrant. */
      models?: number;
      /** Number of components registered by this registrant. */
      components?: number;
      /** Number of relationships registered by this registrant. */
      relationships?: number;
      /** Number of policies registered by this registrant. */
      policies?: number;
    };
  })[];
};
export type GetRegistryRegistrantsApiArg = {
  /** Zero-indexed page number of the result set. */
  page?: number;
  /** Number of items per page, or `all` to return every item. */
  pageSize?: string;
  /** Filter results by a case-insensitive substring match on name. */
  search?: string;
  /** Field to order the results by. */
  order?: string;
  /** Sort direction (`asc` or `desc`). */
  sort?: string;
};
export type RegisterRegistryEntitiesApiResponse =
  /** status 200 Import processed; response summarizes registered entities and failures. */ {
    /** Counts of imported and failed entities by type. */
    entityCount?: {
      /** Number of components imported. */
      compCount?: number;
      /** Number of relationships imported. */
      relCount?: number;
      /** Number of models imported. */
      modelCount?: number;
      /** Number of components that failed to import. */
      errCompCount?: number;
      /** Number of relationships that failed to import. */
      errRelCount?: number;
      /** Number of models that failed to import. */
      errModelCount?: number;
      /** Total number of entities that failed to import. */
      totalErrCount?: number;
    };
    /** Aggregated, human-readable description of import failures, if any. */
    errMsg?: string;
    /** Per-type summaries of imported entities and failures. */
    entityTypeSummary?: {
      /** Components successfully imported. */
      successfulComponents?: {
        [key: string]: any;
      }[];
      /** Relationships successfully imported. */
      successfulRelationships?: {
        [key: string]: any;
      }[];
      /** Models successfully imported. */
      successfulModels?: {
        [key: string]: any;
      }[];
      /** Names of entities that failed to import, with their errors. */
      unsuccessfulComponentNames?: any[];
    };
    /** Names of the models processed by the import. */
    modelName?: string[];
  };
export type RegisterRegistryEntitiesApiArg = {
  body: {
    importBody:
      | {
          /** Name of the file being uploaded. */
          fileName: string;
          /** Supported model file formats are: .tar, .tar.gz, and .tgz. See [Import Models Documentation](https://docs.meshery.io/guides/configuration-management/importing-models#import-models-using-meshery-ui) for details */
          modelFile: string;
        }
      | {
          /** A direct URL to a single model file, for example: https://raw.github.com/your-model-file.tar. Supported model file formats are: .tar, .tar.gz, and .tgz. \n\nFor bulk import of your model use the GitHub connection or CSV files. See [Import Models Documentation](https://docs.meshery.io/guides/configuration-management/importing-models#import-models-using-meshery-ui) for details */
          url: string;
        }
      | {
          /** Upload a CSV file containing model definitions */
          modelCsv: Blob;
          /** Upload a CSV file containing component definitions */
          componentCsv: Blob;
          /** Upload a CSV file containing relationship definitions */
          relationshipCsv: Blob;
        }
      | {
          /** URI to the source code or package of the model. */
          url: string;
        };
    /** Choose the method you prefer to upload your model file. Select 'File Import' or 'CSV Import' if you have the file on your local system or 'URL Import' if you have the file hosted online. */
    uploadType: "file" | "urlImport" | "csv" | "url";
    /** The register of the importrequest. */
    register: boolean;
  };
};
export type GenerateRegistryComponentsApiResponse =
  /** status 200 Generation results, one item per requested package. */ {
    /** Name of the package the components were generated for. */
    name?: string;
    /** The generated component definitions. */
    components?: {
      /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
      id: string;
      /** Specifies the version of the schema to which the component definition conforms. */
      schemaVersion: string;
      /** Version of the component definition. */
      version: string;
      /** Name of the component in human-readable format. */
      displayName: string;
      /** A written representation of the purpose and characteristics of the component. */
      description: string;
      /** Format specifies the format used in the `component.schema` field. JSON is the default. */
      format: "JSON" | "CUE";
      /** 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 */
      model: {
        /** Uniquely identifies the entity (i.e. component) as defined in a declaration (i.e. design). */
        id: string;
        /** Specifies the version of the schema used for the definition. */
        schemaVersion: string;
        /** Version of the model definition. */
        version: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Description of the model. */
        description: string;
        /** Status of model, including:
            - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
            - maintenance: model is unavailable for a period of time.
            - enabled: model is available for use for all users of this Meshery Server.
            - ignored: model is unavailable for use for all users of this Meshery Server. */
        status: "ignored" | "enabled" | "duplicate";
        /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
        registrant: {
          /** Connection ID */
          id: string;
          /** Connection Name */
          name: string;
          /** Associated Credential ID */
          credentialId?: string;
          /** Connection Type (platform, telemetry, collaboration) */
          type: string;
          /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
          subType: string;
          /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
          kind: string;
          /** Additional connection metadata */
          metadata?: object;
          /** Connection Status */
          status:
            | "discovered"
            | "registered"
            | "connected"
            | "ignored"
            | "maintenance"
            | "disconnected"
            | "deleted"
            | "not found";
          /** User ID who owns this connection */
          user_id?: string;
          created_at?: string;
          updated_at?: string;
          /** SQL null Timestamp to handle null values of time. */
          deleted_at?: string;
          /** Associated environments for this connection */
          environments?: {
            /** ID */
            id: string;
            /** Specifies the version of the schema to which the environment conforms. */
            schemaVersion: string;
            /** Environment name */
            name: string;
            /** Environment description */
            description: string;
            /** Environment organization ID */
            organization_id: string;
            /** Environment owner */
            owner?: string;
            /** Timestamp when the resource was created. */
            created_at?: string;
            /** Additional metadata associated with the environment. */
            metadata?: object;
            /** Timestamp when the resource was updated. */
            updated_at?: string;
            /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
            deleted_at?: string | null;
          }[];
          /** Specifies the version of the schema used for the definition. */
          schemaVersion: string;
        };
        /** ID of the registrant. */
        registrantId: string;
        /** ID of the category. */
        categoryId: string;
        /** Category of the model. */
        category: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The category of the model that determines the main grouping. */
          name:
            | "Analytics"
            | "App Definition and Development"
            | "Cloud Native Network"
            | "Cloud Native Storage"
            | "Database"
            | "Machine Learning"
            | "Observability and Analysis"
            | "Orchestration & Management"
            | "Platform"
            | "Provisioning"
            | "Runtime"
            | "Security & Compliance"
            | "Serverless"
            | "Tools"
            | "Uncategorized";
          /** Additional metadata associated with the category. */
          metadata: object;
        };
        /** Sub category of the model determines the secondary grouping. */
        subCategory:
          | "API Gateway"
          | "API Integration"
          | "Application Definition & Image Build"
          | "Automation & Configuration"
          | "Certified Kubernetes - Distribution"
          | "Chaos Engineering"
          | "Cloud Native Storage"
          | "Cloud Provider"
          | "CNI"
          | "Compute"
          | "Container Registry"
          | "Container Runtime"
          | "Container Security"
          | "Container"
          | "Content Delivery Network"
          | "Continuous Integration & Delivery"
          | "Coordination & Service Discovery"
          | "Database"
          | "Flowchart"
          | "Framework"
          | "Installable Platform"
          | "Key Management"
          | "Key Management Service"
          | "Kubernetes"
          | "Logging"
          | "Machine Learning"
          | "Management Governance"
          | "Metrics"
          | "Monitoring"
          | "Networking Content Delivery"
          | "Operating System"
          | "Query"
          | "Remote Procedure Call"
          | "Scheduling & Orchestration"
          | "Secrets Management"
          | "Security Identity & Compliance"
          | "Service Mesh"
          | "Service Proxy"
          | "Source Version Control"
          | "Storage"
          | "Specifications"
          | "Streaming & Messaging"
          | "Tools"
          | "Tracing"
          | "Uncategorized"
          | "Video Conferencing";
        /** Metadata containing additional information associated with the model. */
        metadata?: {
          /** Capabilities associated with the model */
          capabilities?: {
            /** Specifies the version of the schema to which the capability definition conforms. */
            schemaVersion: string;
            /** Version of the capability definition. */
            version: string;
            /** Name of the capability in human-readible format. */
            displayName: string;
            /** A written representation of the purpose and characteristics of the capability. */
            description: string;
            /** Top-level categorization of the capability */
            kind: "action" | "mutate" | "view" | "interaction";
            /** Classification of capabilities. Used to group capabilities similar in nature. */
            type: string;
            /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
            subType: string;
            /** Key that backs the capability. */
            key: string;
            /** State of the entity in which the capability is applicable. */
            entityState: ("declaration" | "instance")[];
            /** Status of the capability */
            status: "enabled" | "disabled";
            /** Metadata contains additional information associated with the capability. Extension point. */
            metadata?: {
              [key: string]: any;
            };
          }[];
          /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
          isAnnotation?: boolean;
          /** Primary color associated with the model. */
          primaryColor?: string;
          /** Secondary color associated with the model. */
          secondaryColor?: string;
          /** SVG representation of the model in white color. */
          svgWhite: string;
          /** SVG representation of the model in colored format. */
          svgColor: string;
          /** SVG representation of the complete model. */
          svgComplete?: string;
          /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
          shape?:
            | "ellipse"
            | "triangle"
            | "round-triangle"
            | "rectangle"
            | "round-rectangle"
            | "bottom-round-rectangle"
            | "cut-rectangle"
            | "barrel"
            | "rhomboid"
            | "diamond"
            | "round-diamond"
            | "pentagon"
            | "round-pentagon"
            | "hexagon"
            | "round-hexagon"
            | "concave-hexagon"
            | "heptagon"
            | "round-heptagon"
            | "octagon"
            | "round-octagon"
            | "star"
            | "tag"
            | "round-tag"
            | "vee"
            | "polygon";
          [key: string]: any;
        };
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        /** The relationships of the model. */
        relationships: any;
        /** The components of the model. */
        components: any;
        /** Number of components associated with the model. */
        componentsCount: number;
        /** Number of relationships associated with the model. */
        relationshipsCount: number;
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
      };
      /** 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 */
      modelReference: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** The unique name for the model within the scope of a registrant. */
        name: string;
        /** Version of the model definition. */
        version: string;
        /** Human-readable name for the model. */
        displayName: string;
        /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
        model: {
          /** Version of the model as defined by the registrant. */
          version: string;
        };
        registrant: {
          /** Kind of the registrant. */
          kind: string;
        };
      };
      /** Foreign key to the model to which the component belongs. Populated by the ORM from the `model_id` column and suppressed on the JSON wire; consumers use the nested `model` object for wire-level access. */
      modelId?: string;
      /** Visualization styles for a component */
      styles?: {
        /** Primary color of the component used for UI representation. */
        primaryColor: string;
        /** Secondary color of the entity used for UI representation. */
        secondaryColor?: string;
        /** White SVG of the entity used for UI representation on dark background. */
        svgWhite: string;
        /** Colored SVG of the entity used for UI representation on light background. */
        svgColor: string;
        /** Complete SVG of the entity used for UI representation, often inclusive of background. */
        svgComplete: string;
        /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
        color?: string;
        /** The opacity of the label text, including its outline. */
        textOpacity?: number;
        /** A comma-separated list of font names to use on the label text. */
        fontFamily?: string;
        /** The size of the label text. */
        fontSize?: string;
        /** A CSS font style to be applied to the label text. */
        fontStyle?: string;
        /** A CSS font weight to be applied to the label text. */
        fontWeight?: string;
        /** A transformation to apply to the label text */
        textTransform?: "none" | "uppercase" | "lowercase";
        /** 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. */
        opacity?: number;
        /** 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. */
        zIndex?: number;
        /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
        label?: string;
        /** The animation to apply to the element. example ripple,bounce,etc */
        animation?: object;
        [key: string]: any;
      } & {
        /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
        shape:
          | "ellipse"
          | "triangle"
          | "round-triangle"
          | "rectangle"
          | "round-rectangle"
          | "bottom-round-rectangle"
          | "cut-rectangle"
          | "barrel"
          | "rhomboid"
          | "diamond"
          | "round-diamond"
          | "pentagon"
          | "round-pentagon"
          | "hexagon"
          | "round-hexagon"
          | "concave-hexagon"
          | "heptagon"
          | "round-heptagon"
          | "octagon"
          | "round-octagon"
          | "star"
          | "tag"
          | "round-tag"
          | "vee"
          | "polygon";
        /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
        position?: {
          /** The x-coordinate of the node. */
          x: number;
          /** The y-coordinate of the node. */
          y: number;
        };
        /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
        bodyText?: string;
        /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
        bodyTextWrap?: "none" | "wrap" | "ellipsis";
        /** The maximum width for wrapping text in the node. */
        bodyTextMaxWidth?: string;
        /** The opacity of the node's body text, including its outline. */
        bodyTextOpacity?: number;
        /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextBackgroundColor?: string;
        /** The size of the node's body text. */
        bodyTextFontSize?: number;
        /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
        bodyTextColor?: string;
        /** A CSS font weight to be applied to the node's body text. */
        bodyTextFontWeight?: string;
        /** A CSS horizontal alignment to be applied to the node's body text. */
        bodyTextHorizontalAlign?: string;
        /** A CSS text decoration to be applied to the node's body text. */
        bodyTextDecoration?: string;
        /** A CSS vertical alignment to be applied to the node's body text. */
        bodyTextVerticalAlign?: string;
        /** The width of the node's body or the width of an edge's line. */
        width?: number;
        /** The height of the node's body */
        height?: number;
        /** The URL that points to the image to show in the node. */
        backgroundImage?: string;
        /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
        backgroundColor?: string;
        /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
        backgroundBlacken?: number;
        /** The opacity level of the node's background colour */
        backgroundOpacity?: number;
        /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionX?: string;
        /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundPositionY?: string;
        /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetX?: string;
        /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
        backgroundOffsetY?: string;
        /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
        backgroundFit?: "none" | "contain" | "cover";
        /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
        backgroundClip?: "none" | "node" | "node-border";
        /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundWidthRelativeTo?: "none" | "inner" | "outer";
        /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
        backgroundHeightRelativeTo?: "none" | "inner" | "outer";
        /** The size of the node's border. */
        borderWidth?: number;
        /** The style of the node's border */
        borderStyle?: "solid" | "dotted" | "dashed" | "double";
        /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
        borderColor?: string;
        /** The opacity of the node's border */
        borderOpacity?: number;
        /** The amount of padding around all sides of the node. */
        padding?: number;
        /** The horizontal alignment of a node's label */
        textHalign?: "left" | "center" | "right";
        /** The vertical alignment of a node's label */
        textValign?: "top" | "center" | "bottom";
        /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
        ghost?: "yes" | "no";
        /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        activeBgColor?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgOpacity?: string;
        /** The opacity of the active background indicator. Selector needs to be *core*. */
        activeBgSize?: string;
        /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        selectionBoxColor?: string;
        /** The size of the border on the selection box. Selector needs to be *core* */
        selectionBoxBorderWidth?: number;
        /** The opacity of the selection box. Selector needs to be *core* */
        selectionBoxOpacity?: number;
        /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
        outsideTextureBgColor?: string;
        /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
        outsideTextureBgOpacity?: number;
        /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
        shapePolygonPoints?: string;
        /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuBackgroundColor?: string;
        /** The opacity of the background of the component menu. */
        menuBackgroundOpacity?: number;
        /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
        menuForgroundColor?: string;
      };
      /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
      capabilities?: {
        /** Specifies the version of the schema to which the capability definition conforms. */
        schemaVersion: string;
        /** Version of the capability definition. */
        version: string;
        /** Name of the capability in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the capability. */
        description: string;
        /** Top-level categorization of the capability */
        kind: "action" | "mutate" | "view" | "interaction";
        /** Classification of capabilities. Used to group capabilities similar in nature. */
        type: string;
        /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
        subType: string;
        /** Key that backs the capability. */
        key: string;
        /** State of the entity in which the capability is applicable. */
        entityState: ("declaration" | "instance")[];
        /** Status of the capability */
        status: "enabled" | "disabled";
        /** Metadata contains additional information associated with the capability. Extension point. */
        metadata?: {
          [key: string]: any;
        };
      }[];
      /** Status of component, including:
        - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
        - maintenance: model is unavailable for a period of time.
        - enabled: model is available for use for all users of this Meshery Server.
        - ignored: model is unavailable for use for all users of this Meshery Server. */
      status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
      /** Metadata contains additional information associated with the component. */
      metadata: {
        /** Genealogy represents the various representational states of the component. */
        genealogy: string;
        /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
        isAnnotation: boolean;
        /** Identifies whether the component is scoped to namespace or cluster wide. */
        isNamespaced: boolean;
        /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
        published: boolean;
        /** InstanceDetails contains information about the instance of the component. */
        instanceDetails: object;
        /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
        configurationUISchema: string;
        [key: string]: any;
      };
      /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
      configuration: object;
      /** Data related to the third-party capability that a ComponentDefinition wraps; this payload is treated as a hermetically sealed, opaque object. */
      component: {
        /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
        version: string;
        /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
        kind: string;
        /** JSON schema of the object as defined by the registrant. */
        schema: string;
      };
      /** Timestamp when the component was created. */
      createdAt: string;
      /** Timestamp when the component was last updated. */
      updatedAt: string;
      /** Timestamp when the component was soft-deleted. Null while the component is active. */
      deletedAt?: string;
    }[];
    /** Errors encountered while generating components for this package. */
    errors?: string[];
  }[];
export type GenerateRegistryComponentsApiArg = {
  body: {
    /** Packages for which to generate components. */
    data: {
      /** Name of the package (Artifact Hub package name) to generate components for. */
      name: string;
      /** Whether to register the generated components into the registry. */
      register?: boolean;
    }[];
  };
};
export type ExportRegistryModelApiResponse = unknown;
export type ExportRegistryModelApiArg = {
  /** ID of the model to export. */
  id?: string;
  /** Name of the model to export. */
  name?: string;
  /** Version of the model to export. */
  version?: string;
  /** Format of the definitions inside the exported artifact. */
  outputFormat?: "json" | "yaml";
  /** Type of artifact to produce. */
  fileType?: "oci" | "tar";
  /** Whether to include component definitions in the export. */
  components?: boolean;
  /** Whether to include relationship definitions in the export. */
  relationships?: boolean;
};
export type ValidateRegistryEntitiesApiResponse =
  /** status 200 Validation results keyed by the request item identifiers. */ {
    result: {
      [key: string]: {
        /** Whether the value conforms to its schema. */
        isValid: boolean;
        /** Validation errors, empty when the value is valid. */
        errors?: string[];
      };
    };
  };
export type ValidateRegistryEntitiesApiArg = {
  body: {
    /** Items to validate, keyed by a caller-chosen identifier. */
    validationItems: {
      [key: string]: {
        /** Schema (JSON Schema or CUE) to validate the value against. */
        schema: string;
        /** Value to validate. */
        value: string;
        /** Format of `value`. */
        valueType?: "JSON" | "YAML" | "JSONSCHEMA" | "CUE";
      };
    };
  };
};
export type UpdateRegistryEntityStatusApiResponse = unknown;
export type UpdateRegistryEntityStatusApiArg = {
  /** Type of the registered entity whose status is being updated. */
  entityType: string;
  body: {
    /** ID of the registered entity whose status is being updated. */
    id?: string;
    /** New status of the entity (e.g. `registered`, `ignored`). */
    status: string;
    /** Display name of the entity, used in the resulting status-change event. */
    displayName?: string;
  };
};
export type GetSystemDatabaseApiResponse = /** status 200 Database summary */ {
  /** Zero-based page index of the returned table slice. */
  page: number;
  /** Number of tables included in this page. */
  pageSize: number;
  /** Total number of tables in the database matching the search filter. */
  totalTables: number;
  /** Aggregate row count across the tables returned in this page. */
  recordCount: number;
  /** Tables included in this page, with per-table row counts. */
  tables: {
    /** Name of the table. */
    name: string;
    /** SQLite object type (e.g. `table`). */
    type: string;
    /** Number of rows currently in the table. */
    count: number;
  }[];
};
export type GetSystemDatabaseApiArg = {
  /** Zero-based page index for the table list. */
  page?: number;
  /** Number of tables to include per page. */
  pageSize?: number;
  /** Substring filter applied to table names. */
  search?: string;
  /** Column to order the table list by. */
  sort?: "name";
  /** Sort direction for the `sort` column. */
  order?: "asc" | "desc";
};
export type ResetSystemDatabaseApiResponse = /** status 200 Database reset */ {
  /** Human-readable status message. */
  message: string;
};
export type ResetSystemDatabaseApiArg = void;
export type GetSystemVersionApiResponse = /** status 200 Server version metadata */ {
  /** Meshery Cloud deployment version. */
  version?: string;
  /** Build identifier (typically the git tag of the running binary). */
  build?: string;
  /** Latest available Meshery release tag fetched from GitHub. */
  latest?: string;
  /** True when the running build is older than the latest available release. */
  outdated?: boolean;
  /** Git commit SHA of the running service. The wire field is `commitsha`. */
  commitsha?: string;
  /** Release channel of the running binary (e.g. `stable`, `edge`). */
  releaseChannel?: string;
};
export type GetSystemVersionApiArg = void;
export type AddKubernetesConfigApiResponse = /** status 200 Discovered contexts bucketed by import outcome. */ {
  /** Contexts newly registered as discovered connections. */
  registeredContexts: {
    /** Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
    id?: string;
    /** Human-readable name of the Kubernetes context. */
    name?: string;
    /** Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
    auth?: object;
    /** Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
    cluster?: object;
    /** API server URL of the Kubernetes cluster. */
    server?: string;
    /** ID of the user who owns the underlying connection. */
    owner?: string;
    /** ID of the user who registered the context. */
    createdBy?: string;
    /** ID of the Meshery instance the context is registered with. */
    mesheryInstanceId?: string;
    /** ID of the Kubernetes server associated with the context. */
    kubernetesServerId?: string;
    /** How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
    deploymentType?: string;
    /** Kubernetes server version of the cluster. */
    version?: string;
    /** Timestamp when the underlying connection was created. */
    createdAt?: string;
    /** Timestamp when the underlying connection was last updated. */
    updatedAt?: string;
    /** ID of the connection this context was projected from. */
    connectionId?: string;
    /** Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
    reachable?: boolean;
  }[];
  /** Contexts whose connection already exists in (or transitioned to) the connected state. */
  connectedContexts: {
    /** Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
    id?: string;
    /** Human-readable name of the Kubernetes context. */
    name?: string;
    /** Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
    auth?: object;
    /** Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
    cluster?: object;
    /** API server URL of the Kubernetes cluster. */
    server?: string;
    /** ID of the user who owns the underlying connection. */
    owner?: string;
    /** ID of the user who registered the context. */
    createdBy?: string;
    /** ID of the Meshery instance the context is registered with. */
    mesheryInstanceId?: string;
    /** ID of the Kubernetes server associated with the context. */
    kubernetesServerId?: string;
    /** How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
    deploymentType?: string;
    /** Kubernetes server version of the cluster. */
    version?: string;
    /** Timestamp when the underlying connection was created. */
    createdAt?: string;
    /** Timestamp when the underlying connection was last updated. */
    updatedAt?: string;
    /** ID of the connection this context was projected from. */
    connectionId?: string;
    /** Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
    reachable?: boolean;
  }[];
  /** Contexts whose connection is in the ignored state. */
  ignoredContexts: {
    /** Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
    id?: string;
    /** Human-readable name of the Kubernetes context. */
    name?: string;
    /** Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
    auth?: object;
    /** Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
    cluster?: object;
    /** API server URL of the Kubernetes cluster. */
    server?: string;
    /** ID of the user who owns the underlying connection. */
    owner?: string;
    /** ID of the user who registered the context. */
    createdBy?: string;
    /** ID of the Meshery instance the context is registered with. */
    mesheryInstanceId?: string;
    /** ID of the Kubernetes server associated with the context. */
    kubernetesServerId?: string;
    /** How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
    deploymentType?: string;
    /** Kubernetes server version of the cluster. */
    version?: string;
    /** Timestamp when the underlying connection was created. */
    createdAt?: string;
    /** Timestamp when the underlying connection was last updated. */
    updatedAt?: string;
    /** ID of the connection this context was projected from. */
    connectionId?: string;
    /** Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
    reachable?: boolean;
  }[];
  /** Contexts that could not be saved as connections. The failure detail is recorded in the emitted event's metadata, not on the context object. */
  erroredContexts: {
    /** Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
    id?: string;
    /** Human-readable name of the Kubernetes context. */
    name?: string;
    /** Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
    auth?: object;
    /** Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
    cluster?: object;
    /** API server URL of the Kubernetes cluster. */
    server?: string;
    /** ID of the user who owns the underlying connection. */
    owner?: string;
    /** ID of the user who registered the context. */
    createdBy?: string;
    /** ID of the Meshery instance the context is registered with. */
    mesheryInstanceId?: string;
    /** ID of the Kubernetes server associated with the context. */
    kubernetesServerId?: string;
    /** How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
    deploymentType?: string;
    /** Kubernetes server version of the cluster. */
    version?: string;
    /** Timestamp when the underlying connection was created. */
    createdAt?: string;
    /** Timestamp when the underlying connection was last updated. */
    updatedAt?: string;
    /** ID of the connection this context was projected from. */
    connectionId?: string;
    /** Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
    reachable?: boolean;
  }[];
};
export type AddKubernetesConfigApiArg = {
  body: {
    /** Kubeconfig file contents. */
    k8sfile: Blob;
    /** JSON-encoded object mapping a discovered context ID to per-context import options, e.g. `{"<contextId>": {"meshsyncDeploymentMode": "operator", "name": "my-cluster"}}`. `meshsyncDeploymentMode` selects how MeshSync runs for the resulting connection; `name` overrides the connection name. */
    contexts?: string;
    /** JSON-encoded array of discovered context IDs to import. When absent, every context discovered in the kubeconfig is imported. */
    selectedContexts?: string;
  };
};
export type DiscoverKubernetesContextsApiResponse = /** status 200 Contexts discovered in the uploaded kubeconfig. */ {
  /** Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
  id?: string;
  /** Human-readable name of the Kubernetes context. */
  name?: string;
  /** Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
  auth?: object;
  /** Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
  cluster?: object;
  /** API server URL of the Kubernetes cluster. */
  server?: string;
  /** ID of the user who owns the underlying connection. */
  owner?: string;
  /** ID of the user who registered the context. */
  createdBy?: string;
  /** ID of the Meshery instance the context is registered with. */
  mesheryInstanceId?: string;
  /** ID of the Kubernetes server associated with the context. */
  kubernetesServerId?: string;
  /** How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
  deploymentType?: string;
  /** Kubernetes server version of the cluster. */
  version?: string;
  /** Timestamp when the underlying connection was created. */
  createdAt?: string;
  /** Timestamp when the underlying connection was last updated. */
  updatedAt?: string;
  /** ID of the connection this context was projected from. */
  connectionId?: string;
  /** Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
  reachable?: boolean;
}[];
export type DiscoverKubernetesContextsApiArg = {
  body: {
    /** Kubeconfig file contents. */
    k8sfile: Blob;
  };
};
export type PingKubernetesApiResponse = /** status 200 Cluster is reachable. */ {
  /** Version string reported by the cluster's API server. The wire field is `server_version` - this endpoint's published wire casing predates the camelCase convention and is preserved within this API version. */
  server_version: string;
};
export type PingKubernetesApiArg = {
  /** ID of the Kubernetes connection whose cluster to ping. */
  connectionId: string;
};
export type GetSystemSyncApiResponse = /** status 200 Session sync payload */ {
  /** Kubernetes contexts currently tracked by the Meshery server. */
  k8sConfig?: {
    /** Stable identifier for the Kubernetes context. */
    id?: string;
    /** Human-readable name of the Kubernetes context. */
    name?: string;
    /** True when Meshery has a usable kubeconfig for this context. */
    clusterConfigured?: boolean;
    /** API server URL for the Kubernetes context. */
    server?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    clusterId?: string;
    /** When the context was first registered with Meshery. */
    createdAt?: string;
    /** When the context was last updated. */
    updatedAt?: string;
  }[];
  [key: string]: any;
};
export type GetSystemSyncApiArg = void;
export type GetOperatorControllerStatusApiResponse = /** status 200 Operator controller status */ {
  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
  connectionId: string;
  /** The controller this status describes. */
  controller: "OPERATOR" | "MESHSYNC" | "BROKER";
  /** Current controller status. */
  status: "DEPLOYED" | "NOTDEPLOYED" | "DEPLOYING" | "UNKOWN" | "UNDEPLOYED" | "ENABLED" | "RUNNING" | "CONNECTED";
  /** Deployed controller version, when known. */
  version: string;
};
export type GetOperatorControllerStatusApiArg = {
  /** The kubernetes connection ID whose operator status is requested. */
  connectionId: string;
};
export type GetMeshsyncControllerStatusApiResponse = /** status 200 MeshSync controller status */ {
  /** Controller name (e.g. MeshSync, MesheryBroker). */
  name: string;
  /** Deployed controller version, when known. */
  version: string;
  /** Current controller status. May be composed, e.g. "Connected <endpoint>". */
  status: string;
  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
  connectionId: string;
};
export type GetMeshsyncControllerStatusApiArg = {
  /** The kubernetes connection ID whose MeshSync status is requested. */
  connectionId: string;
};
export type GetBrokerControllerStatusApiResponse = /** status 200 Broker controller status */ {
  /** Controller name (e.g. MeshSync, MesheryBroker). */
  name: string;
  /** Deployed controller version, when known. */
  version: string;
  /** Current controller status. May be composed, e.g. "Connected <endpoint>". */
  status: string;
  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
  connectionId: string;
};
export type GetBrokerControllerStatusApiArg = {
  /** The kubernetes connection ID whose broker status is requested. */
  connectionId: string;
};
export type GetControllerDiagnosticsApiResponse = /** status 200 Connection controller diagnostics */ {
  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
  connectionId: string;
  /** True when no warning/error diagnostics were detected (informational diagnostics do not affect health). */
  healthy: boolean;
  /** The diagnostics detected for this connection (possibly empty). */
  diagnostics: {
    /** How serious the diagnostic is. */
    severity: "info" | "warning" | "error";
    /** The controller this diagnostic concerns, when applicable. */
    controller?: "OPERATOR" | "MESHSYNC" | "BROKER";
    /** Stable machine-readable code for this diagnostic (e.g. `broker_unreachable`), for the UI to key on. */
    code: string;
    /** Short, human-readable title for the diagnostic. */
    summary: string;
    /** A fuller explanation of what is wrong and why. */
    description?: string;
    /** Ordered, concrete steps the user can take to resolve the issue. */
    remediation?: string[];
    /** A relevant endpoint for the diagnostic, when applicable (e.g. the broker's published address the user needs to make reachable). */
    endpoint?: string;
  }[];
};
export type GetControllerDiagnosticsApiArg = {
  /** The kubernetes connection ID whose diagnostics are requested. */
  connectionId: string;
};
export type SubscribeControllersStatusApiResponse = unknown;
export type SubscribeControllersStatusApiArg = {
  /** Kubernetes connection IDs to watch. Repeatable (connectionIds=<id>&connectionIds=<id>). */
  connectionIds?: string[];
};
export type GetUserCredentialsApiResponse = /** status 200 Credentials response */ {
  /** The credentials returned on the current page. */
  credentials: {
    /** Unique identifier for the credential. */
    id: string;
    /** Human-readable name for the credential. */
    name: string;
    /** UUID of the user who owns this credential. */
    userId: string;
    /** Credential type (e.g. token, basic, AWS). */
    type: string;
    /** Key-value pairs containing the sensitive credential data. */
    secret?: object;
    /** Timestamp when the credential was created. */
    createdAt: string;
    /** Timestamp when the credential was last updated. */
    updatedAt: string;
    /** Timestamp when the credential was soft-deleted. */
    deletedAt?: string;
  }[];
  /** Total number of credentials across all pages. */
  totalCount: number;
  /** Current page number (zero-based). */
  page: number;
  /** Number of credentials per page. */
  pageSize: number;
};
export type GetUserCredentialsApiArg = {
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
};
export type SaveUserCredentialApiResponse = /** status 201 Credential saved */ {
  /** Unique identifier for the credential. */
  id: string;
  /** Human-readable name for the credential. */
  name: string;
  /** UUID of the user who owns this credential. */
  userId: string;
  /** Credential type (e.g. token, basic, AWS). */
  type: string;
  /** Key-value pairs containing the sensitive credential data. */
  secret?: object;
  /** Timestamp when the credential was created. */
  createdAt: string;
  /** Timestamp when the credential was last updated. */
  updatedAt: string;
  /** Timestamp when the credential was soft-deleted. */
  deletedAt?: string;
};
export type SaveUserCredentialApiArg = {
  body: {
    /** Existing credential ID for updates; omit on create. */
    id?: string;
    /** Human-readable name for the credential. */
    name: string;
    /** UUID of the user who owns this credential. */
    userId?: string;
    /** Credential type (e.g. token, basic, AWS). */
    type: string;
    /** Key-value pairs containing the sensitive credential data. */
    secret?: object;
  };
};
export type UpdateUserCredentialApiResponse = /** status 200 Credential updated */ {
  /** Unique identifier for the credential. */
  id: string;
  /** Human-readable name for the credential. */
  name: string;
  /** UUID of the user who owns this credential. */
  userId: string;
  /** Credential type (e.g. token, basic, AWS). */
  type: string;
  /** Key-value pairs containing the sensitive credential data. */
  secret?: object;
  /** Timestamp when the credential was created. */
  createdAt: string;
  /** Timestamp when the credential was last updated. */
  updatedAt: string;
  /** Timestamp when the credential was soft-deleted. */
  deletedAt?: string;
};
export type UpdateUserCredentialApiArg = {
  body: {
    /** Existing credential ID for updates; omit on create. */
    id?: string;
    /** Human-readable name for the credential. */
    name: string;
    /** UUID of the user who owns this credential. */
    userId?: string;
    /** Credential type (e.g. token, basic, AWS). */
    type: string;
    /** Key-value pairs containing the sensitive credential data. */
    secret?: object;
  };
};
export type DeleteUserCredentialApiResponse = unknown;
export type DeleteUserCredentialApiArg = {
  /** Credential ID */
  credentialId: string;
};
export type GetCredentialByIdApiResponse = /** status 200 Credential response */ {
  /** Unique identifier for the credential. */
  id: string;
  /** Human-readable name for the credential. */
  name: string;
  /** UUID of the user who owns this credential. */
  userId: string;
  /** Credential type (e.g. token, basic, AWS). */
  type: string;
  /** Key-value pairs containing the sensitive credential data. */
  secret?: object;
  /** Timestamp when the credential was created. */
  createdAt: string;
  /** Timestamp when the credential was last updated. */
  updatedAt: string;
  /** Timestamp when the credential was soft-deleted. */
  deletedAt?: string;
};
export type GetCredentialByIdApiArg = {
  /** Credential ID */
  credentialId: string;
};
export type GetUserKeysApiResponse = /** status 200 Returns user keys based on roles assigned to user */ {
  /** Zero-based page index returned in this response. */
  page: number;
  /** Maximum number of items returned on each page. */
  pageSize: number;
  /** Total number of items across all pages. */
  totalCount: number;
  /** Keys returned on the current page. */
  keys: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    id: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    owner: string;
    /** Operation permitted by the key. */
    function: string;
    /** Category for the key. */
    category: string;
    /** Subcategory for the key. */
    subcategory: string;
    /** Human readable description of the key. */
    description: string;
    /** Timestamp when the key was created. */
    createdAt: string;
    /** Timestamp when the key was last updated. */
    updatedAt: string;
    /** Timestamp when the key was soft-deleted. */
    deletedAt?: string | null;
  }[];
};
export type GetUserKeysApiArg = {
  /** Organization ID */
  orgId: string;
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
};
export type GetOrgsApiResponse = /** status 200 Organizations response */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Organizations in this page. */
  organizations?: {
    /** Organization ID. */
    id?: string;
    /** Name of the organization. */
    name?: string;
    /** Description of the organization. */
    description?: string;
    /** Country of the organization. */
    country?: string;
    /** Region of the organization. */
    region?: string;
    /** Custom domain assigned to the organization, when configured. */
    domain?: string;
    /** Display name of the organization owner. */
    owner?: string;
    /** Free-form metadata associated with an organization, including preferences. */
    metadata?: {
      /** Organization-level user experience preferences. */
      preferences: {
        /** UI theme configured for an organization. */
        theme: {
          /** Theme identifier. */
          id: string;
          /** Themed logo assets used across light and dark, desktop and mobile presentations. */
          logo: {
            /** Image asset anchored to a named location within an organization theme. */
            desktopView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            mobileView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            darkDesktopView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            darkMobileView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
          };
          /** Arbitrary theme variables keyed by name. */
          vars?: {
            [key: string]: any;
          };
        };
        /** Preferences specific to dashboard behavior. */
        dashboard: {
          [key: string]: any;
        };
        /** Optional per-organization branding overrides for the auth pages: carousel slides and FAQ entries. Stored as JSON inside organization.metadata.preferences, so no dedicated column backs it. Empty or omitted fields fall back to the platform defaults. */
        authBranding?: {
          /** Ordered slides rendered in the auth-page feature carousel. */
          carousel?: {
            /** URL of the slide image asset. */
            imageUrl: string;
            /** Slide title. */
            title: string;
            /** Slide description text. */
            description: string;
          }[];
          /** FAQ entries rendered on the auth pages. */
          faqs?: {
            /** The question text. */
            question: string;
            /** The answer text. */
            answer: string;
          }[];
        };
        /** Per-organization overrides for the legal and support links shown on the auth pages and the error page. termsOfService and privacy are the named legal links; support is an open-ended set of named support contacts/links. Empty or omitted fields fall back to the platform defaults. */
        links?: {
          /** URL of the organization's Terms of Service page. */
          termsOfService?: string;
          /** URL of the organization's Privacy Policy page. */
          privacy?: string;
          /** Open-ended set of named support contacts/links rendered on the auth and error pages, keyed by display name with a value that is a URL, a mailto:/tel: link, or free text. For example a "slack" entry pointing at https://slack.meshery.io, a "discussion forum" entry, or a "support desk" entry holding a phone number. */
          support?: {
            [key: string]: string;
          };
        };
        /** Whether the feature carousel renders on the organization's auth pages. Unset is treated as true (shown); set false to hide it. */
        showAuthCarousel?: boolean;
      };
    };
    /** Timestamp when the organization was created. */
    createdAt?: string;
    /** Timestamp when the organization was last updated. */
    updatedAt?: string;
    /** Timestamp when the organization was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type GetOrgsApiArg = {
  /** Zero-based index of the result page to return. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get all possible entries */
  all?: boolean;
};
export type CreateOrgApiResponse = /** status 201 Single-organization page response */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Organizations returned in this single-item page wrapper. */
  organizations?: {
    /** Organization ID. */
    id?: string;
    /** Name of the organization. */
    name?: string;
    /** Description of the organization. */
    description?: string;
    /** Country of the organization. */
    country?: string;
    /** Region of the organization. */
    region?: string;
    /** Custom domain assigned to the organization, when configured. */
    domain?: string;
    /** Display name of the organization owner. */
    owner?: string;
    /** Free-form metadata associated with an organization, including preferences. */
    metadata?: {
      /** Organization-level user experience preferences. */
      preferences: {
        /** UI theme configured for an organization. */
        theme: {
          /** Theme identifier. */
          id: string;
          /** Themed logo assets used across light and dark, desktop and mobile presentations. */
          logo: {
            /** Image asset anchored to a named location within an organization theme. */
            desktopView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            mobileView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            darkDesktopView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            darkMobileView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
          };
          /** Arbitrary theme variables keyed by name. */
          vars?: {
            [key: string]: any;
          };
        };
        /** Preferences specific to dashboard behavior. */
        dashboard: {
          [key: string]: any;
        };
        /** Optional per-organization branding overrides for the auth pages: carousel slides and FAQ entries. Stored as JSON inside organization.metadata.preferences, so no dedicated column backs it. Empty or omitted fields fall back to the platform defaults. */
        authBranding?: {
          /** Ordered slides rendered in the auth-page feature carousel. */
          carousel?: {
            /** URL of the slide image asset. */
            imageUrl: string;
            /** Slide title. */
            title: string;
            /** Slide description text. */
            description: string;
          }[];
          /** FAQ entries rendered on the auth pages. */
          faqs?: {
            /** The question text. */
            question: string;
            /** The answer text. */
            answer: string;
          }[];
        };
        /** Per-organization overrides for the legal and support links shown on the auth pages and the error page. termsOfService and privacy are the named legal links; support is an open-ended set of named support contacts/links. Empty or omitted fields fall back to the platform defaults. */
        links?: {
          /** URL of the organization's Terms of Service page. */
          termsOfService?: string;
          /** URL of the organization's Privacy Policy page. */
          privacy?: string;
          /** Open-ended set of named support contacts/links rendered on the auth and error pages, keyed by display name with a value that is a URL, a mailto:/tel: link, or free text. For example a "slack" entry pointing at https://slack.meshery.io, a "discussion forum" entry, or a "support desk" entry holding a phone number. */
          support?: {
            [key: string]: string;
          };
        };
        /** Whether the feature carousel renders on the organization's auth pages. Unset is treated as true (shown); set false to hide it. */
        showAuthCarousel?: boolean;
      };
    };
    /** Timestamp when the organization was created. */
    createdAt?: string;
    /** Timestamp when the organization was last updated. */
    updatedAt?: string;
    /** Timestamp when the organization was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type CreateOrgApiArg = {
  /** Body for creating or updating an organization */
  body: {
    /** Name of the organization. */
    name?: string;
    /** Country of the organization. */
    country?: string;
    /** Region of the organization. */
    region?: string;
    /** Description of the organization. */
    description?: string;
    /** Indicates whether organization members should be notified of this update. */
    notifyOrgUpdate?: boolean;
    /** Organization-level user experience preferences. */
    preferences?: {
      /** UI theme configured for an organization. */
      theme: {
        /** Theme identifier. */
        id: string;
        /** Themed logo assets used across light and dark, desktop and mobile presentations. */
        logo: {
          /** Image asset anchored to a named location within an organization theme. */
          desktopView: {
            /** SVG markup for the asset. */
            svg: string;
            /** Named location of the asset (e.g. header, footer). */
            location: string;
          };
          /** Image asset anchored to a named location within an organization theme. */
          mobileView: {
            /** SVG markup for the asset. */
            svg: string;
            /** Named location of the asset (e.g. header, footer). */
            location: string;
          };
          /** Image asset anchored to a named location within an organization theme. */
          darkDesktopView: {
            /** SVG markup for the asset. */
            svg: string;
            /** Named location of the asset (e.g. header, footer). */
            location: string;
          };
          /** Image asset anchored to a named location within an organization theme. */
          darkMobileView: {
            /** SVG markup for the asset. */
            svg: string;
            /** Named location of the asset (e.g. header, footer). */
            location: string;
          };
        };
        /** Arbitrary theme variables keyed by name. */
        vars?: {
          [key: string]: any;
        };
      };
      /** Preferences specific to dashboard behavior. */
      dashboard: {
        [key: string]: any;
      };
      /** Optional per-organization branding overrides for the auth pages: carousel slides and FAQ entries. Stored as JSON inside organization.metadata.preferences, so no dedicated column backs it. Empty or omitted fields fall back to the platform defaults. */
      authBranding?: {
        /** Ordered slides rendered in the auth-page feature carousel. */
        carousel?: {
          /** URL of the slide image asset. */
          imageUrl: string;
          /** Slide title. */
          title: string;
          /** Slide description text. */
          description: string;
        }[];
        /** FAQ entries rendered on the auth pages. */
        faqs?: {
          /** The question text. */
          question: string;
          /** The answer text. */
          answer: string;
        }[];
      };
      /** Per-organization overrides for the legal and support links shown on the auth pages and the error page. termsOfService and privacy are the named legal links; support is an open-ended set of named support contacts/links. Empty or omitted fields fall back to the platform defaults. */
      links?: {
        /** URL of the organization's Terms of Service page. */
        termsOfService?: string;
        /** URL of the organization's Privacy Policy page. */
        privacy?: string;
        /** Open-ended set of named support contacts/links rendered on the auth and error pages, keyed by display name with a value that is a URL, a mailto:/tel: link, or free text. For example a "slack" entry pointing at https://slack.meshery.io, a "discussion forum" entry, or a "support desk" entry holding a phone number. */
        support?: {
          [key: string]: string;
        };
      };
      /** Whether the feature carousel renders on the organization's auth pages. Unset is treated as true (shown); set false to hide it. */
      showAuthCarousel?: boolean;
    };
  };
};
export type GetOrgByDomainApiResponse = /** status 200 Organization response */ {
  /** Organization ID. */
  id: string;
  /** Name of the organization. */
  name: string;
  /** Country of the organization. */
  country: string;
  /** Region of the organization. */
  region: string;
  /** Description of the organization. */
  description: string;
  /** Owner user ID of the organization. */
  owner: string;
  /** Free-form metadata associated with the organization, including preferences. */
  metadata: object;
  /** Domain of the organization. */
  domain?: string | null;
  /** Timestamp when the organization was created. */
  createdAt: string;
  /** Timestamp when the organization was last updated. */
  updatedAt: string;
  /** Timestamp when the organization was soft-deleted. Null while the organization is active. */
  deletedAt?: string;
};
export type GetOrgByDomainApiArg = {
  /** Domain name of the organization to look up. */
  domain: string;
};
export type GetOrgApiResponse = /** status 200 Single-organization page response */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Organizations returned in this single-item page wrapper. */
  organizations?: {
    /** Organization ID. */
    id?: string;
    /** Name of the organization. */
    name?: string;
    /** Description of the organization. */
    description?: string;
    /** Country of the organization. */
    country?: string;
    /** Region of the organization. */
    region?: string;
    /** Custom domain assigned to the organization, when configured. */
    domain?: string;
    /** Display name of the organization owner. */
    owner?: string;
    /** Free-form metadata associated with an organization, including preferences. */
    metadata?: {
      /** Organization-level user experience preferences. */
      preferences: {
        /** UI theme configured for an organization. */
        theme: {
          /** Theme identifier. */
          id: string;
          /** Themed logo assets used across light and dark, desktop and mobile presentations. */
          logo: {
            /** Image asset anchored to a named location within an organization theme. */
            desktopView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            mobileView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            darkDesktopView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            darkMobileView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
          };
          /** Arbitrary theme variables keyed by name. */
          vars?: {
            [key: string]: any;
          };
        };
        /** Preferences specific to dashboard behavior. */
        dashboard: {
          [key: string]: any;
        };
        /** Optional per-organization branding overrides for the auth pages: carousel slides and FAQ entries. Stored as JSON inside organization.metadata.preferences, so no dedicated column backs it. Empty or omitted fields fall back to the platform defaults. */
        authBranding?: {
          /** Ordered slides rendered in the auth-page feature carousel. */
          carousel?: {
            /** URL of the slide image asset. */
            imageUrl: string;
            /** Slide title. */
            title: string;
            /** Slide description text. */
            description: string;
          }[];
          /** FAQ entries rendered on the auth pages. */
          faqs?: {
            /** The question text. */
            question: string;
            /** The answer text. */
            answer: string;
          }[];
        };
        /** Per-organization overrides for the legal and support links shown on the auth pages and the error page. termsOfService and privacy are the named legal links; support is an open-ended set of named support contacts/links. Empty or omitted fields fall back to the platform defaults. */
        links?: {
          /** URL of the organization's Terms of Service page. */
          termsOfService?: string;
          /** URL of the organization's Privacy Policy page. */
          privacy?: string;
          /** Open-ended set of named support contacts/links rendered on the auth and error pages, keyed by display name with a value that is a URL, a mailto:/tel: link, or free text. For example a "slack" entry pointing at https://slack.meshery.io, a "discussion forum" entry, or a "support desk" entry holding a phone number. */
          support?: {
            [key: string]: string;
          };
        };
        /** Whether the feature carousel renders on the organization's auth pages. Unset is treated as true (shown); set false to hide it. */
        showAuthCarousel?: boolean;
      };
    };
    /** Timestamp when the organization was created. */
    createdAt?: string;
    /** Timestamp when the organization was last updated. */
    updatedAt?: string;
    /** Timestamp when the organization was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type GetOrgApiArg = {
  /** Organization ID. */
  orgId: string;
};
export type DeleteOrgApiResponse = unknown;
export type DeleteOrgApiArg = {
  /** Organization ID. */
  orgId: string;
};
export type UpdateOrgApiResponse = /** status 200 Single-organization page response for the updated organization */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Organizations returned in this single-item page wrapper. */
  organizations?: {
    /** Organization ID. */
    id?: string;
    /** Name of the organization. */
    name?: string;
    /** Description of the organization. */
    description?: string;
    /** Country of the organization. */
    country?: string;
    /** Region of the organization. */
    region?: string;
    /** Custom domain assigned to the organization, when configured. */
    domain?: string;
    /** Display name of the organization owner. */
    owner?: string;
    /** Free-form metadata associated with an organization, including preferences. */
    metadata?: {
      /** Organization-level user experience preferences. */
      preferences: {
        /** UI theme configured for an organization. */
        theme: {
          /** Theme identifier. */
          id: string;
          /** Themed logo assets used across light and dark, desktop and mobile presentations. */
          logo: {
            /** Image asset anchored to a named location within an organization theme. */
            desktopView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            mobileView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            darkDesktopView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
            /** Image asset anchored to a named location within an organization theme. */
            darkMobileView: {
              /** SVG markup for the asset. */
              svg: string;
              /** Named location of the asset (e.g. header, footer). */
              location: string;
            };
          };
          /** Arbitrary theme variables keyed by name. */
          vars?: {
            [key: string]: any;
          };
        };
        /** Preferences specific to dashboard behavior. */
        dashboard: {
          [key: string]: any;
        };
        /** Optional per-organization branding overrides for the auth pages: carousel slides and FAQ entries. Stored as JSON inside organization.metadata.preferences, so no dedicated column backs it. Empty or omitted fields fall back to the platform defaults. */
        authBranding?: {
          /** Ordered slides rendered in the auth-page feature carousel. */
          carousel?: {
            /** URL of the slide image asset. */
            imageUrl: string;
            /** Slide title. */
            title: string;
            /** Slide description text. */
            description: string;
          }[];
          /** FAQ entries rendered on the auth pages. */
          faqs?: {
            /** The question text. */
            question: string;
            /** The answer text. */
            answer: string;
          }[];
        };
        /** Per-organization overrides for the legal and support links shown on the auth pages and the error page. termsOfService and privacy are the named legal links; support is an open-ended set of named support contacts/links. Empty or omitted fields fall back to the platform defaults. */
        links?: {
          /** URL of the organization's Terms of Service page. */
          termsOfService?: string;
          /** URL of the organization's Privacy Policy page. */
          privacy?: string;
          /** Open-ended set of named support contacts/links rendered on the auth and error pages, keyed by display name with a value that is a URL, a mailto:/tel: link, or free text. For example a "slack" entry pointing at https://slack.meshery.io, a "discussion forum" entry, or a "support desk" entry holding a phone number. */
          support?: {
            [key: string]: string;
          };
        };
        /** Whether the feature carousel renders on the organization's auth pages. Unset is treated as true (shown); set false to hide it. */
        showAuthCarousel?: boolean;
      };
    };
    /** Timestamp when the organization was created. */
    createdAt?: string;
    /** Timestamp when the organization was last updated. */
    updatedAt?: string;
    /** Timestamp when the organization was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type UpdateOrgApiArg = {
  /** Organization ID. */
  orgId: string;
  /** Body for creating or updating an organization */
  body: {
    /** Name of the organization. */
    name?: string;
    /** Country of the organization. */
    country?: string;
    /** Region of the organization. */
    region?: string;
    /** Description of the organization. */
    description?: string;
    /** Indicates whether organization members should be notified of this update. */
    notifyOrgUpdate?: boolean;
    /** Organization-level user experience preferences. */
    preferences?: {
      /** UI theme configured for an organization. */
      theme: {
        /** Theme identifier. */
        id: string;
        /** Themed logo assets used across light and dark, desktop and mobile presentations. */
        logo: {
          /** Image asset anchored to a named location within an organization theme. */
          desktopView: {
            /** SVG markup for the asset. */
            svg: string;
            /** Named location of the asset (e.g. header, footer). */
            location: string;
          };
          /** Image asset anchored to a named location within an organization theme. */
          mobileView: {
            /** SVG markup for the asset. */
            svg: string;
            /** Named location of the asset (e.g. header, footer). */
            location: string;
          };
          /** Image asset anchored to a named location within an organization theme. */
          darkDesktopView: {
            /** SVG markup for the asset. */
            svg: string;
            /** Named location of the asset (e.g. header, footer). */
            location: string;
          };
          /** Image asset anchored to a named location within an organization theme. */
          darkMobileView: {
            /** SVG markup for the asset. */
            svg: string;
            /** Named location of the asset (e.g. header, footer). */
            location: string;
          };
        };
        /** Arbitrary theme variables keyed by name. */
        vars?: {
          [key: string]: any;
        };
      };
      /** Preferences specific to dashboard behavior. */
      dashboard: {
        [key: string]: any;
      };
      /** Optional per-organization branding overrides for the auth pages: carousel slides and FAQ entries. Stored as JSON inside organization.metadata.preferences, so no dedicated column backs it. Empty or omitted fields fall back to the platform defaults. */
      authBranding?: {
        /** Ordered slides rendered in the auth-page feature carousel. */
        carousel?: {
          /** URL of the slide image asset. */
          imageUrl: string;
          /** Slide title. */
          title: string;
          /** Slide description text. */
          description: string;
        }[];
        /** FAQ entries rendered on the auth pages. */
        faqs?: {
          /** The question text. */
          question: string;
          /** The answer text. */
          answer: string;
        }[];
      };
      /** Per-organization overrides for the legal and support links shown on the auth pages and the error page. termsOfService and privacy are the named legal links; support is an open-ended set of named support contacts/links. Empty or omitted fields fall back to the platform defaults. */
      links?: {
        /** URL of the organization's Terms of Service page. */
        termsOfService?: string;
        /** URL of the organization's Privacy Policy page. */
        privacy?: string;
        /** Open-ended set of named support contacts/links rendered on the auth and error pages, keyed by display name with a value that is a URL, a mailto:/tel: link, or free text. For example a "slack" entry pointing at https://slack.meshery.io, a "discussion forum" entry, or a "support desk" entry holding a phone number. */
        support?: {
          [key: string]: string;
        };
      };
      /** Whether the feature carousel renders on the organization's auth pages. Unset is treated as true (shown); set false to hide it. */
      showAuthCarousel?: boolean;
    };
  };
};
export type GetOrgPreferencesApiResponse = /** status 200 Organization metadata, including preferences */ {
  /** Organization-level user experience preferences. */
  preferences: {
    /** UI theme configured for an organization. */
    theme: {
      /** Theme identifier. */
      id: string;
      /** Themed logo assets used across light and dark, desktop and mobile presentations. */
      logo: {
        /** Image asset anchored to a named location within an organization theme. */
        desktopView: {
          /** SVG markup for the asset. */
          svg: string;
          /** Named location of the asset (e.g. header, footer). */
          location: string;
        };
        /** Image asset anchored to a named location within an organization theme. */
        mobileView: {
          /** SVG markup for the asset. */
          svg: string;
          /** Named location of the asset (e.g. header, footer). */
          location: string;
        };
        /** Image asset anchored to a named location within an organization theme. */
        darkDesktopView: {
          /** SVG markup for the asset. */
          svg: string;
          /** Named location of the asset (e.g. header, footer). */
          location: string;
        };
        /** Image asset anchored to a named location within an organization theme. */
        darkMobileView: {
          /** SVG markup for the asset. */
          svg: string;
          /** Named location of the asset (e.g. header, footer). */
          location: string;
        };
      };
      /** Arbitrary theme variables keyed by name. */
      vars?: {
        [key: string]: any;
      };
    };
    /** Preferences specific to dashboard behavior. */
    dashboard: {
      [key: string]: any;
    };
    /** Optional per-organization branding overrides for the auth pages: carousel slides and FAQ entries. Stored as JSON inside organization.metadata.preferences, so no dedicated column backs it. Empty or omitted fields fall back to the platform defaults. */
    authBranding?: {
      /** Ordered slides rendered in the auth-page feature carousel. */
      carousel?: {
        /** URL of the slide image asset. */
        imageUrl: string;
        /** Slide title. */
        title: string;
        /** Slide description text. */
        description: string;
      }[];
      /** FAQ entries rendered on the auth pages. */
      faqs?: {
        /** The question text. */
        question: string;
        /** The answer text. */
        answer: string;
      }[];
    };
    /** Per-organization overrides for the legal and support links shown on the auth pages and the error page. termsOfService and privacy are the named legal links; support is an open-ended set of named support contacts/links. Empty or omitted fields fall back to the platform defaults. */
    links?: {
      /** URL of the organization's Terms of Service page. */
      termsOfService?: string;
      /** URL of the organization's Privacy Policy page. */
      privacy?: string;
      /** Open-ended set of named support contacts/links rendered on the auth and error pages, keyed by display name with a value that is a URL, a mailto:/tel: link, or free text. For example a "slack" entry pointing at https://slack.meshery.io, a "discussion forum" entry, or a "support desk" entry holding a phone number. */
      support?: {
        [key: string]: string;
      };
    };
    /** Whether the feature carousel renders on the organization's auth pages. Unset is treated as true (shown); set false to hide it. */
    showAuthCarousel?: boolean;
  };
};
export type GetOrgPreferencesApiArg = {
  /** Organization ID. */
  orgId: string;
};
export type AddTeamToOrgApiResponse = /** status 201 Team added to organization or team tombstoned */
  | {
      /** Zero-based page index returned in this response. */
      page?: number;
      /** Maximum number of items returned on each page. */
      pageSize?: number;
      /** Total number of items across all pages. */
      totalCount?: number;
      /** Team-organization mapping entries. */
      teamsOrganizationsMapping?: {
        /** Mapping record ID. */
        id?: string;
        /** Organization ID for this mapping. */
        orgId?: string;
        /** Team ID for this mapping. */
        teamId?: string;
        /** Timestamp when the mapping was created. */
        createdAt?: string;
        /** Timestamp when the mapping was last updated. */
        updatedAt?: string;
        /** Timestamp when the mapping was soft-deleted. */
        deletedAt?: string;
      }[];
    }
  | {
      /** Zero-based page index returned in this response. */
      page?: number;
      /** Maximum number of items returned on each page. */
      pageSize?: number;
      /** Total number of items across all pages. */
      totalCount?: number;
      /** Teams in this page. */
      teams?: {
        /** Team ID. */
        id?: string;
        /** Name of the team. */
        name?: string;
        /** Description of the team. */
        description?: string;
        /** Display name of the team owner. */
        owner?: string;
        /** Free-form team metadata. */
        metadata?: {
          [key: string]: string;
        };
        /** Timestamp when the team was created. */
        createdAt?: string;
        /** Timestamp when the team was last updated. */
        updatedAt?: string;
        /** Timestamp when the team was soft-deleted. */
        deletedAt?: string;
      }[];
    };
export type AddTeamToOrgApiArg = {
  /** Organization ID. */
  orgId: string;
  /** Team ID. */
  teamId: string;
  body: {
    /** Internal action to perform on the team resource. */
    action?: "delete";
  };
};
export type RemoveTeamFromOrgApiResponse = /** status 200 Team removed from organization */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Team-organization mapping entries. */
  teamsOrganizationsMapping?: {
    /** Mapping record ID. */
    id?: string;
    /** Organization ID for this mapping. */
    orgId?: string;
    /** Team ID for this mapping. */
    teamId?: string;
    /** Timestamp when the mapping was created. */
    createdAt?: string;
    /** Timestamp when the mapping was last updated. */
    updatedAt?: string;
    /** Timestamp when the mapping was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type RemoveTeamFromOrgApiArg = {
  /** Organization ID. */
  orgId: string;
  /** Team ID. */
  teamId: string;
};
export type AddUserToOrgApiResponse = /** status 201 User added to organization */ {
  [key: string]: any;
};
export type AddUserToOrgApiArg = {
  /** Organization ID. */
  orgId: string;
  /** User ID. */
  userId: string;
};
export type DeleteUserFromOrgApiResponse = unknown;
export type DeleteUserFromOrgApiArg = {
  /** Organization ID. */
  orgId: string;
  /** User ID. */
  userId: string;
};
export type GetUsersForOrgApiResponse = /** status 200 Paginated list of organization users */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items per page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** The data of the userspageforadmin. */
  data?: {
    /** Unique identifier for the user */
    id: string;
    /** Legacy IdP-derived identifier. Removed in v1beta3; resolve users by id or email. */
    userId: string;
    /** Authentication provider (e.g., Google, Github) */
    provider: string;
    /** User's email address */
    email: string;
    /** User's first name */
    firstName: string;
    /** User's last name */
    lastName: string;
    /** URL to user's avatar image */
    avatarUrl?: string;
    /** User account status */
    status: "active" | "inactive" | "pending" | "anonymous";
    /** User's biography or description */
    bio?: string;
    /** User's country information stored as JSONB */
    country?: {
      [key: string]: any;
    };
    /** User's region information stored as JSONB */
    region?: {
      [key: string]: any;
    };
    /** User preferences stored as JSONB */
    preferences?: {
      /** The mesh adapters of the preference. */
      meshAdapters?: object[];
      grafana?: {
        /** Grafana URL for the user configuration. */
        grafanaUrl?: string;
        /** Grafana API key for the user configuration. */
        grafanaApiKey?: string;
        /** Selected Grafana board configurations for the user. */
        selectedBoardsConfigs?: {
          /** Placeholder for GrafanaBoard definition (define fields as needed) */
          board?: object;
          /** Panels selected for the Grafana board configuration. */
          panels?: object[];
          /** Template variables applied to the selected Grafana board configuration. */
          templateVars?: string[];
        }[];
      };
      prometheus?: {
        /** The prometheus URL of the prometheus. */
        prometheusUrl?: string;
        /** The selected prometheus boards configs of the prometheus. */
        selectedPrometheusBoardsConfigs?: {
          /** Placeholder for GrafanaBoard definition (define fields as needed) */
          board?: object;
          /** Panels selected for the Grafana board configuration. */
          panels?: object[];
          /** Template variables applied to the selected Grafana board configuration. */
          templateVars?: string[];
        }[];
      };
      loadTestPrefs?: {
        /** Concurrent requests */
        c?: number;
        /** Queries per second */
        qps?: number;
        /** Duration */
        t?: string;
        /** Load generator */
        gen?: string;
      };
      /** The anonymous usage stats of the preference. */
      anonymousUsageStats: boolean;
      /** The anonymous perf results of the preference. */
      anonymousPerfResults: boolean;
      /** Timestamp of when the resource was last updated. */
      updatedAt: string;
      /** The dashboard preferences of the preference. */
      dashboardPreferences: {
        [key: string]: any;
      };
      /** ID of the associated selectedOrganization. */
      selectedOrganizationId: string;
      /** The selected workspace for organizations of the preference. */
      selectedWorkspaceForOrganizations: {
        [key: string]: string;
      };
      /** The users extension preferences of the preference. */
      usersExtensionPreferences: {
        [key: string]: any;
      };
      /** The remote provider preferences of the preference. */
      remoteProviderPreferences: {
        [key: string]: any;
      };
    };
    /** Timestamp when user accepted terms and conditions */
    acceptedTermsAt?: string;
    /** Timestamp of user's first login */
    firstLoginTime?: string;
    /** Timestamp of user's most recent login */
    lastLoginTime: string;
    /** Timestamp when the user record was created */
    createdAt: string;
    /** Timestamp when the user record was last updated */
    updatedAt: string;
    /** Various online profiles associated with the user account */
    socials?: {
      /** The site of the social. */
      site: string;
      /** The link of the social. */
      link: string;
    }[];
    /** Timestamp when the user record was soft-deleted (null if not deleted) */
    deletedAt: string | null;
    /** Names of the global roles assigned to the user. Free-form, user-generated values sourced from the roles table (role_name is a varchar, not a fixed enumeration); the seeded system roles such as "admin", "organization admin" and "user" are a subset, not the whole set. */
    roleNames?: string[];
    /** Teams the user belongs to with role information */
    teams?: {
      /** Team memberships for the user with their assigned roles. */
      teamsWithRoles?: {
        /** Unique identifier of the team. */
        id: string;
        /** Name of the team. */
        name: string;
        /** Human readable description of the team. */
        description?: string;
        /** Identifier of the team owner. */
        owner?: string;
        /** Free-form metadata associated with the team. */
        metadata?: {
          [key: string]: any;
        };
        /** Timestamp when the team was created. */
        createdAt?: string;
        /** Timestamp when the team was last updated. */
        updatedAt?: string;
        /** Timestamp when the team was soft-deleted (null if not deleted). */
        deletedAt?: string | null;
        /** Names of the roles assigned to the user within this team. Free-form, user-generated role names; not a fixed enumeration. */
        roleNames: string[];
      }[];
      /** Total number of team memberships returned for the user. */
      totalCount?: number;
    };
    /** Organizations the user belongs to with role information */
    organizations?: {
      /** Organization memberships for the user with their assigned roles. */
      organizationsWithRoles?: {
        /** Unique identifier of the organization. */
        id: string;
        /** Name of the organization. */
        name: string;
        /** Human readable description of the organization. */
        description?: string;
        /** Country associated with the organization. */
        country?: string;
        /** Region associated with the organization. */
        region?: string;
        /** Identifier of the organization owner. */
        owner?: string;
        /** Timestamp when the organization was created. */
        createdAt?: string;
        /** Timestamp when the organization was last updated. */
        updatedAt?: string;
        /** Timestamp when the organization was soft-deleted (null if not deleted). */
        deletedAt?: string | null;
        /** Names of the roles assigned to the user within this organization. Free-form, user-generated role names; not a fixed enumeration. */
        roleNames: string[];
      }[];
      /** Total number of organization memberships returned for the user. */
      totalCount?: number;
    };
  }[];
};
export type GetUsersForOrgApiArg = {
  /** Organization ID */
  orgId: string;
  /** Get responses by page */
  page?: number;
  /** Get responses by page size */
  pageSize?: number;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get filtered reponses */
  filter?: string;
  /** Optional team filter when listing organization users */
  teamId?: string;
};
export type GetUserProfileByIdApiResponse = /** status 200 User profile for the requested ID */ {
  /** Unique identifier for the user */
  id: string;
  /** Legacy IdP-derived identifier. Removed in v1beta3; resolve users by id or email. */
  userId: string;
  /** Authentication provider (e.g., Google, Github) */
  provider: string;
  /** User's email address */
  email: string;
  /** User's first name */
  firstName: string;
  /** User's last name */
  lastName: string;
  /** URL to user's avatar image */
  avatarUrl?: string;
  /** User account status */
  status: "active" | "inactive" | "pending" | "anonymous";
  /** User's biography or description */
  bio?: string;
  /** User's country information stored as JSONB */
  country?: {
    [key: string]: any;
  };
  /** User's region information stored as JSONB */
  region?: {
    [key: string]: any;
  };
  /** User preferences stored as JSONB */
  preferences?: {
    /** The mesh adapters of the preference. */
    meshAdapters?: object[];
    grafana?: {
      /** Grafana URL for the user configuration. */
      grafanaUrl?: string;
      /** Grafana API key for the user configuration. */
      grafanaApiKey?: string;
      /** Selected Grafana board configurations for the user. */
      selectedBoardsConfigs?: {
        /** Placeholder for GrafanaBoard definition (define fields as needed) */
        board?: object;
        /** Panels selected for the Grafana board configuration. */
        panels?: object[];
        /** Template variables applied to the selected Grafana board configuration. */
        templateVars?: string[];
      }[];
    };
    prometheus?: {
      /** The prometheus URL of the prometheus. */
      prometheusUrl?: string;
      /** The selected prometheus boards configs of the prometheus. */
      selectedPrometheusBoardsConfigs?: {
        /** Placeholder for GrafanaBoard definition (define fields as needed) */
        board?: object;
        /** Panels selected for the Grafana board configuration. */
        panels?: object[];
        /** Template variables applied to the selected Grafana board configuration. */
        templateVars?: string[];
      }[];
    };
    loadTestPrefs?: {
      /** Concurrent requests */
      c?: number;
      /** Queries per second */
      qps?: number;
      /** Duration */
      t?: string;
      /** Load generator */
      gen?: string;
    };
    /** The anonymous usage stats of the preference. */
    anonymousUsageStats: boolean;
    /** The anonymous perf results of the preference. */
    anonymousPerfResults: boolean;
    /** Timestamp of when the resource was last updated. */
    updatedAt: string;
    /** The dashboard preferences of the preference. */
    dashboardPreferences: {
      [key: string]: any;
    };
    /** ID of the associated selectedOrganization. */
    selectedOrganizationId: string;
    /** The selected workspace for organizations of the preference. */
    selectedWorkspaceForOrganizations: {
      [key: string]: string;
    };
    /** The users extension preferences of the preference. */
    usersExtensionPreferences: {
      [key: string]: any;
    };
    /** The remote provider preferences of the preference. */
    remoteProviderPreferences: {
      [key: string]: any;
    };
  };
  /** Timestamp when user accepted terms and conditions */
  acceptedTermsAt?: string;
  /** Timestamp of user's first login */
  firstLoginTime?: string;
  /** Timestamp of user's most recent login */
  lastLoginTime: string;
  /** Timestamp when the user record was created */
  createdAt: string;
  /** Timestamp when the user record was last updated */
  updatedAt: string;
  /** Various online profiles associated with the user account */
  socials?: {
    /** The site of the social. */
    site: string;
    /** The link of the social. */
    link: string;
  }[];
  /** Timestamp when the user record was soft-deleted (null if not deleted) */
  deletedAt: string | null;
  /** Names of the global roles assigned to the user. Free-form, user-generated values sourced from the roles table (role_name is a varchar, not a fixed enumeration); the seeded system roles such as "admin", "organization admin" and "user" are a subset, not the whole set. */
  roleNames?: string[];
  /** Teams the user belongs to with role information */
  teams?: {
    /** Team memberships for the user with their assigned roles. */
    teamsWithRoles?: {
      /** Unique identifier of the team. */
      id: string;
      /** Name of the team. */
      name: string;
      /** Human readable description of the team. */
      description?: string;
      /** Identifier of the team owner. */
      owner?: string;
      /** Free-form metadata associated with the team. */
      metadata?: {
        [key: string]: any;
      };
      /** Timestamp when the team was created. */
      createdAt?: string;
      /** Timestamp when the team was last updated. */
      updatedAt?: string;
      /** Timestamp when the team was soft-deleted (null if not deleted). */
      deletedAt?: string | null;
      /** Names of the roles assigned to the user within this team. Free-form, user-generated role names; not a fixed enumeration. */
      roleNames: string[];
    }[];
    /** Total number of team memberships returned for the user. */
    totalCount?: number;
  };
  /** Organizations the user belongs to with role information */
  organizations?: {
    /** Organization memberships for the user with their assigned roles. */
    organizationsWithRoles?: {
      /** Unique identifier of the organization. */
      id: string;
      /** Name of the organization. */
      name: string;
      /** Human readable description of the organization. */
      description?: string;
      /** Country associated with the organization. */
      country?: string;
      /** Region associated with the organization. */
      region?: string;
      /** Identifier of the organization owner. */
      owner?: string;
      /** Timestamp when the organization was created. */
      createdAt?: string;
      /** Timestamp when the organization was last updated. */
      updatedAt?: string;
      /** Timestamp when the organization was soft-deleted (null if not deleted). */
      deletedAt?: string | null;
      /** Names of the roles assigned to the user within this organization. Free-form, user-generated role names; not a fixed enumeration. */
      roleNames: string[];
    }[];
    /** Total number of organization memberships returned for the user. */
    totalCount?: number;
  };
};
export type GetUserProfileByIdApiArg = {
  /** User ID */
  id: string;
};
export type GetUserApiResponse = /** status 200 Current user profile and role context */ {
  /** Unique identifier for the user */
  id: string;
  /** Legacy IdP-derived identifier. Removed in v1beta3; resolve users by id or email. */
  userId: string;
  /** Authentication provider (e.g., Google, Github) */
  provider: string;
  /** User's email address */
  email: string;
  /** User's first name */
  firstName: string;
  /** User's last name */
  lastName: string;
  /** URL to user's avatar image */
  avatarUrl?: string;
  /** User account status */
  status: "active" | "inactive" | "pending" | "anonymous";
  /** User's biography or description */
  bio?: string;
  /** User's country information stored as JSONB */
  country?: {
    [key: string]: any;
  };
  /** User's region information stored as JSONB */
  region?: {
    [key: string]: any;
  };
  /** User preferences stored as JSONB */
  preferences?: {
    /** The mesh adapters of the preference. */
    meshAdapters?: object[];
    grafana?: {
      /** Grafana URL for the user configuration. */
      grafanaUrl?: string;
      /** Grafana API key for the user configuration. */
      grafanaApiKey?: string;
      /** Selected Grafana board configurations for the user. */
      selectedBoardsConfigs?: {
        /** Placeholder for GrafanaBoard definition (define fields as needed) */
        board?: object;
        /** Panels selected for the Grafana board configuration. */
        panels?: object[];
        /** Template variables applied to the selected Grafana board configuration. */
        templateVars?: string[];
      }[];
    };
    prometheus?: {
      /** The prometheus URL of the prometheus. */
      prometheusUrl?: string;
      /** The selected prometheus boards configs of the prometheus. */
      selectedPrometheusBoardsConfigs?: {
        /** Placeholder for GrafanaBoard definition (define fields as needed) */
        board?: object;
        /** Panels selected for the Grafana board configuration. */
        panels?: object[];
        /** Template variables applied to the selected Grafana board configuration. */
        templateVars?: string[];
      }[];
    };
    loadTestPrefs?: {
      /** Concurrent requests */
      c?: number;
      /** Queries per second */
      qps?: number;
      /** Duration */
      t?: string;
      /** Load generator */
      gen?: string;
    };
    /** The anonymous usage stats of the preference. */
    anonymousUsageStats: boolean;
    /** The anonymous perf results of the preference. */
    anonymousPerfResults: boolean;
    /** Timestamp of when the resource was last updated. */
    updatedAt: string;
    /** The dashboard preferences of the preference. */
    dashboardPreferences: {
      [key: string]: any;
    };
    /** ID of the associated selectedOrganization. */
    selectedOrganizationId: string;
    /** The selected workspace for organizations of the preference. */
    selectedWorkspaceForOrganizations: {
      [key: string]: string;
    };
    /** The users extension preferences of the preference. */
    usersExtensionPreferences: {
      [key: string]: any;
    };
    /** The remote provider preferences of the preference. */
    remoteProviderPreferences: {
      [key: string]: any;
    };
  };
  /** Timestamp when user accepted terms and conditions */
  acceptedTermsAt?: string;
  /** Timestamp of user's first login */
  firstLoginTime?: string;
  /** Timestamp of user's most recent login */
  lastLoginTime: string;
  /** Timestamp when the user record was created */
  createdAt: string;
  /** Timestamp when the user record was last updated */
  updatedAt: string;
  /** Various online profiles associated with the user account */
  socials?: {
    /** The site of the social. */
    site: string;
    /** The link of the social. */
    link: string;
  }[];
  /** Timestamp when the user record was soft-deleted (null if not deleted) */
  deletedAt: string | null;
  /** Names of the global roles assigned to the user. Free-form, user-generated values sourced from the roles table (role_name is a varchar, not a fixed enumeration); the seeded system roles such as "admin", "organization admin" and "user" are a subset, not the whole set. */
  roleNames?: string[];
  /** Teams the user belongs to with role information */
  teams?: {
    /** Team memberships for the user with their assigned roles. */
    teamsWithRoles?: {
      /** Unique identifier of the team. */
      id: string;
      /** Name of the team. */
      name: string;
      /** Human readable description of the team. */
      description?: string;
      /** Identifier of the team owner. */
      owner?: string;
      /** Free-form metadata associated with the team. */
      metadata?: {
        [key: string]: any;
      };
      /** Timestamp when the team was created. */
      createdAt?: string;
      /** Timestamp when the team was last updated. */
      updatedAt?: string;
      /** Timestamp when the team was soft-deleted (null if not deleted). */
      deletedAt?: string | null;
      /** Names of the roles assigned to the user within this team. Free-form, user-generated role names; not a fixed enumeration. */
      roleNames: string[];
    }[];
    /** Total number of team memberships returned for the user. */
    totalCount?: number;
  };
  /** Organizations the user belongs to with role information */
  organizations?: {
    /** Organization memberships for the user with their assigned roles. */
    organizationsWithRoles?: {
      /** Unique identifier of the organization. */
      id: string;
      /** Name of the organization. */
      name: string;
      /** Human readable description of the organization. */
      description?: string;
      /** Country associated with the organization. */
      country?: string;
      /** Region associated with the organization. */
      region?: string;
      /** Identifier of the organization owner. */
      owner?: string;
      /** Timestamp when the organization was created. */
      createdAt?: string;
      /** Timestamp when the organization was last updated. */
      updatedAt?: string;
      /** Timestamp when the organization was soft-deleted (null if not deleted). */
      deletedAt?: string | null;
      /** Names of the roles assigned to the user within this organization. Free-form, user-generated role names; not a fixed enumeration. */
      roleNames: string[];
    }[];
    /** Total number of organization memberships returned for the user. */
    totalCount?: number;
  };
};
export type GetUserApiArg = void;
export type GetUserEmailAddressesApiResponse = /** status 200 Email addresses associated with the requested user */ {
  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
  id: string;
  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
  userId: string;
  /** The email address */
  email: string;
  /** Whether the address was verified (per Kratos verifiable addresses) at record time */
  verified: boolean;
  /** Exactly one live primary address per user; mirrors users.email */
  isPrimary: boolean;
  /** How this address became associated with the account */
  source: "signup" | "consolidation" | "backfill" | "manual";
  createdAt: string;
  updatedAt: string;
  /** SQL null Timestamp to handle null values of time. */
  deletedAt?: string | null;
}[];
export type GetUserEmailAddressesApiArg = {
  /** ID of the user */
  userId: string;
};
export type GetConnectionsApiResponse = /** status 200 Paginated list of connections with summary information */ {
  /** List of connections on this page */
  connections: {
    /** Connection ID */
    id: string;
    /** Connection Name */
    name: string;
    /** Human-readable description of the connection and its purpose. */
    description?: string;
    /** URL of the remote resource this connection points to (e.g. the Helm repository URL, the Kubernetes API server endpoint, the Grafana instance URL). */
    url?: string;
    /** Associated Credential ID */
    credentialId?: string;
    /** Connection Type (platform, telemetry, collaboration) */
    type: string;
    /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
    subType: string;
    /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
    kind: string;
    /** 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 */
    modelReference?: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Version of the model definition. */
      version: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      registrant: {
        /** Kind of the registrant. */
        kind: string;
      };
    };
    /** Additional connection metadata */
    metadata?: object;
    /** Schema for the credential Associated with the connection */
    credentialSchema?: object;
    /** Schema for the connection */
    connectionSchema?: object;
    /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Connection Status */
    status:
      | "discovered"
      | "registered"
      | "connected"
      | "ignored"
      | "maintenance"
      | "disconnected"
      | "deleted"
      | "not found";
    /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status, along with a description of each transition. */
    transitionMap?: {
      [key: string]: {
        /** Connection Status Value */
        nextState:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** Human-readable explanation of when or why this transition occurs. */
        description?: string;
      }[];
    };
    /** User ID who owns this connection */
    owner?: string;
    /** Timestamp when the connection was created. */
    createdAt?: string;
    /** Timestamp when the connection was last updated. */
    updatedAt?: string;
    /** Timestamp when the connection was soft-deleted, if applicable. */
    deletedAt?: string | null;
    /** Associated environments for this connection */
    environments?: {
      /** ID */
      id: string;
      /** Specifies the version of the schema to which the environment conforms. */
      schemaVersion: string;
      /** Environment name */
      name: string;
      /** Environment description */
      description: string;
      /** Environment organization ID */
      organizationId: string;
      /** Environment owner */
      owner?: string;
      /** Timestamp when the environment was created. */
      createdAt?: string;
      /** Additional metadata associated with the environment. */
      metadata?: object;
      /** Timestamp when the environment was last updated. */
      updatedAt?: string;
      /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
      deletedAt?: string | null;
    }[];
    /** Specifies the version of the schema used for the definition. */
    schemaVersion: string;
  }[];
  /** Total number of connections on all pages */
  totalCount: number;
  /** Current page number */
  page: number;
  /** Number of elements per page */
  pageSize: number;
  /** Aggregate count of connections grouped by status */
  statusSummary?: {
    [key: string]: number;
  };
};
export type GetConnectionsApiArg = {
  /** Page number */
  page?: number;
  /** Number of items per page */
  pageSize?: number;
  /** Search term */
  search?: string;
  /** Sort order */
  order?: string;
  /** Organization ID to scope the request. */
  orgId?: string;
  /** Filter connections (general filter string) */
  filter?: string;
  /** Filter by connection kind (e.g., kubernetes, prometheus, grafana) */
  kind?: string[];
  /** Filter by connection status */
  status?: (
    | "discovered"
    | "registered"
    | "connected"
    | "ignored"
    | "maintenance"
    | "disconnected"
    | "deleted"
    | "not found"
  )[];
  /** Filter by connection type */
  type?: string[];
  /** Filter by connection name (partial match supported) */
  name?: string;
};
export type RegisterConnectionApiResponse = /** status 201 Connection registered */ {
  /** Connection ID */
  id: string;
  /** Connection Name */
  name: string;
  /** Human-readable description of the connection and its purpose. */
  description?: string;
  /** URL of the remote resource this connection points to (e.g. the Helm repository URL, the Kubernetes API server endpoint, the Grafana instance URL). */
  url?: string;
  /** Associated Credential ID */
  credentialId?: string;
  /** Connection Type (platform, telemetry, collaboration) */
  type: string;
  /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
  subType: string;
  /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
  kind: string;
  /** 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 */
  modelReference?: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    id: string;
    /** The unique name for the model within the scope of a registrant. */
    name: string;
    /** Version of the model definition. */
    version: string;
    /** Human-readable name for the model. */
    displayName: string;
    /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
    model: {
      /** Version of the model as defined by the registrant. */
      version: string;
    };
    registrant: {
      /** Kind of the registrant. */
      kind: string;
    };
  };
  /** Additional connection metadata */
  metadata?: object;
  /** Schema for the credential Associated with the connection */
  credentialSchema?: object;
  /** Schema for the connection */
  connectionSchema?: object;
  /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
  styles?: {
    /** Primary color of the component used for UI representation. */
    primaryColor: string;
    /** Secondary color of the entity used for UI representation. */
    secondaryColor?: string;
    /** White SVG of the entity used for UI representation on dark background. */
    svgWhite: string;
    /** Colored SVG of the entity used for UI representation on light background. */
    svgColor: string;
    /** Complete SVG of the entity used for UI representation, often inclusive of background. */
    svgComplete: string;
    /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
    color?: string;
    /** The opacity of the label text, including its outline. */
    textOpacity?: number;
    /** A comma-separated list of font names to use on the label text. */
    fontFamily?: string;
    /** The size of the label text. */
    fontSize?: string;
    /** A CSS font style to be applied to the label text. */
    fontStyle?: string;
    /** A CSS font weight to be applied to the label text. */
    fontWeight?: string;
    /** A transformation to apply to the label text */
    textTransform?: "none" | "uppercase" | "lowercase";
    /** 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. */
    opacity?: number;
    /** 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. */
    zIndex?: number;
    /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
    label?: string;
    /** The animation to apply to the element. example ripple,bounce,etc */
    animation?: object;
    [key: string]: any;
  } & {
    /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
    shape:
      | "ellipse"
      | "triangle"
      | "round-triangle"
      | "rectangle"
      | "round-rectangle"
      | "bottom-round-rectangle"
      | "cut-rectangle"
      | "barrel"
      | "rhomboid"
      | "diamond"
      | "round-diamond"
      | "pentagon"
      | "round-pentagon"
      | "hexagon"
      | "round-hexagon"
      | "concave-hexagon"
      | "heptagon"
      | "round-heptagon"
      | "octagon"
      | "round-octagon"
      | "star"
      | "tag"
      | "round-tag"
      | "vee"
      | "polygon";
    /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
    position?: {
      /** The x-coordinate of the node. */
      x: number;
      /** The y-coordinate of the node. */
      y: number;
    };
    /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
    bodyText?: string;
    /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
    bodyTextWrap?: "none" | "wrap" | "ellipsis";
    /** The maximum width for wrapping text in the node. */
    bodyTextMaxWidth?: string;
    /** The opacity of the node's body text, including its outline. */
    bodyTextOpacity?: number;
    /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
    bodyTextBackgroundColor?: string;
    /** The size of the node's body text. */
    bodyTextFontSize?: number;
    /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
    bodyTextColor?: string;
    /** A CSS font weight to be applied to the node's body text. */
    bodyTextFontWeight?: string;
    /** A CSS horizontal alignment to be applied to the node's body text. */
    bodyTextHorizontalAlign?: string;
    /** A CSS text decoration to be applied to the node's body text. */
    bodyTextDecoration?: string;
    /** A CSS vertical alignment to be applied to the node's body text. */
    bodyTextVerticalAlign?: string;
    /** The width of the node's body or the width of an edge's line. */
    width?: number;
    /** The height of the node's body */
    height?: number;
    /** The URL that points to the image to show in the node. */
    backgroundImage?: string;
    /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
    backgroundColor?: string;
    /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
    backgroundBlacken?: number;
    /** The opacity level of the node's background colour */
    backgroundOpacity?: number;
    /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundPositionX?: string;
    /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundPositionY?: string;
    /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundOffsetX?: string;
    /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundOffsetY?: string;
    /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
    backgroundFit?: "none" | "contain" | "cover";
    /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
    backgroundClip?: "none" | "node" | "node-border";
    /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
    backgroundWidthRelativeTo?: "none" | "inner" | "outer";
    /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
    backgroundHeightRelativeTo?: "none" | "inner" | "outer";
    /** The size of the node's border. */
    borderWidth?: number;
    /** The style of the node's border */
    borderStyle?: "solid" | "dotted" | "dashed" | "double";
    /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
    borderColor?: string;
    /** The opacity of the node's border */
    borderOpacity?: number;
    /** The amount of padding around all sides of the node. */
    padding?: number;
    /** The horizontal alignment of a node's label */
    textHalign?: "left" | "center" | "right";
    /** The vertical alignment of a node's label */
    textValign?: "top" | "center" | "bottom";
    /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
    ghost?: "yes" | "no";
    /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    activeBgColor?: string;
    /** The opacity of the active background indicator. Selector needs to be *core*. */
    activeBgOpacity?: string;
    /** The opacity of the active background indicator. Selector needs to be *core*. */
    activeBgSize?: string;
    /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    selectionBoxColor?: string;
    /** The size of the border on the selection box. Selector needs to be *core* */
    selectionBoxBorderWidth?: number;
    /** The opacity of the selection box. Selector needs to be *core* */
    selectionBoxOpacity?: number;
    /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    outsideTextureBgColor?: string;
    /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
    outsideTextureBgOpacity?: number;
    /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
    shapePolygonPoints?: string;
    /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
    menuBackgroundColor?: string;
    /** The opacity of the background of the component menu. */
    menuBackgroundOpacity?: number;
    /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
    menuForgroundColor?: string;
  };
  /** Connection Status */
  status:
    | "discovered"
    | "registered"
    | "connected"
    | "ignored"
    | "maintenance"
    | "disconnected"
    | "deleted"
    | "not found";
  /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status, along with a description of each transition. */
  transitionMap?: {
    [key: string]: {
      /** Connection Status Value */
      nextState:
        | "discovered"
        | "registered"
        | "connected"
        | "ignored"
        | "maintenance"
        | "disconnected"
        | "deleted"
        | "not found";
      /** Human-readable explanation of when or why this transition occurs. */
      description?: string;
    }[];
  };
  /** User ID who owns this connection */
  owner?: string;
  /** Timestamp when the connection was created. */
  createdAt?: string;
  /** Timestamp when the connection was last updated. */
  updatedAt?: string;
  /** Timestamp when the connection was soft-deleted, if applicable. */
  deletedAt?: string | null;
  /** Associated environments for this connection */
  environments?: {
    /** ID */
    id: string;
    /** Specifies the version of the schema to which the environment conforms. */
    schemaVersion: string;
    /** Environment name */
    name: string;
    /** Environment description */
    description: string;
    /** Environment organization ID */
    organizationId: string;
    /** Environment owner */
    owner?: string;
    /** Timestamp when the environment was created. */
    createdAt?: string;
    /** Additional metadata associated with the environment. */
    metadata?: object;
    /** Timestamp when the environment was last updated. */
    updatedAt?: string;
    /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
    deletedAt?: string | null;
  }[];
  /** Specifies the version of the schema used for the definition. */
  schemaVersion: string;
};
export type RegisterConnectionApiArg = {
  body: {
    /** Connection ID */
    id?: string;
    /** Connection name */
    name: string;
    /** Connection kind */
    kind: string;
    /** Connection type */
    type: string;
    /** Connection sub-type */
    subType: string;
    /** Credential secret data */
    credentialSecret?: object;
    /** Connection metadata */
    metadata?: object;
    /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Connection status */
    status: string;
    /** Associated credential ID */
    credentialId?: string;
  };
};
export type ProcessConnectionRegistrationApiResponse =
  /** status 200 Registration bootstrap for status `initialize`; empty body for every other status. */ {
    /** Registration process tracker to echo on subsequent events. */
    id: string;
    /** Registry component definition (`{Kind}Connection`) describing the connection, including its JSON-encoded `schema`. */
    connection: object;
    /** Registry component definition (`{Kind}Credential`) describing the credential, including its JSON-encoded `schema`. Absent when the kind defines no credential component. */
    credential?: object;
  };
export type ProcessConnectionRegistrationApiArg = {
  body: {
    /** Registration process tracker. Returned by the `initialize` bootstrap or minted client-side; echoed on every subsequent event for the same registration. */
    id?: string;
    /** Connection kind (e.g. `kubernetes`, `grafana`, `prometheus`). */
    kind: string;
    /** State-machine event to dispatch. `initialize` returns the registration bootstrap; every other event advances the tracked registration. `not found` is the machine's literal event name. */
    status:
      | "initialize"
      | "discovery"
      | "register"
      | "connect"
      | "disconnect"
      | "ignore"
      | "delete"
      | "not found"
      | "noop"
      | "exit";
    /** Connection name. */
    name?: string;
    /** Connection type. */
    type?: string;
    /** Connection sub-type. */
    subType?: string;
    /** Registry model the connection's definition belongs to. */
    model?: string;
    /** Connection metadata gathered so far in the flow. */
    metadata?: object;
    /** Credential secret material for the connection. */
    credentialSecret?: object;
    /** Existing credential to associate instead of a new secret. */
    credentialId?: string;
    /** When true the server registers the connection without verifying the supplied credential first. */
    skipCredentialVerification?: boolean;
  };
};
export type CancelConnectionRegisterApiResponse = unknown;
export type CancelConnectionRegisterApiArg = {
  /** Registration process tracker id to discard. */
  registrationId: string;
};
export type GetConnectionByIdApiResponse = /** status 200 Connection details */ {
  /** Connection ID */
  id: string;
  /** Connection Name */
  name: string;
  /** Human-readable description of the connection and its purpose. */
  description?: string;
  /** URL of the remote resource this connection points to (e.g. the Helm repository URL, the Kubernetes API server endpoint, the Grafana instance URL). */
  url?: string;
  /** Associated Credential ID */
  credentialId?: string;
  /** Connection Type (platform, telemetry, collaboration) */
  type: string;
  /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
  subType: string;
  /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
  kind: string;
  /** 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 */
  modelReference?: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    id: string;
    /** The unique name for the model within the scope of a registrant. */
    name: string;
    /** Version of the model definition. */
    version: string;
    /** Human-readable name for the model. */
    displayName: string;
    /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
    model: {
      /** Version of the model as defined by the registrant. */
      version: string;
    };
    registrant: {
      /** Kind of the registrant. */
      kind: string;
    };
  };
  /** Additional connection metadata */
  metadata?: object;
  /** Schema for the credential Associated with the connection */
  credentialSchema?: object;
  /** Schema for the connection */
  connectionSchema?: object;
  /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
  styles?: {
    /** Primary color of the component used for UI representation. */
    primaryColor: string;
    /** Secondary color of the entity used for UI representation. */
    secondaryColor?: string;
    /** White SVG of the entity used for UI representation on dark background. */
    svgWhite: string;
    /** Colored SVG of the entity used for UI representation on light background. */
    svgColor: string;
    /** Complete SVG of the entity used for UI representation, often inclusive of background. */
    svgComplete: string;
    /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
    color?: string;
    /** The opacity of the label text, including its outline. */
    textOpacity?: number;
    /** A comma-separated list of font names to use on the label text. */
    fontFamily?: string;
    /** The size of the label text. */
    fontSize?: string;
    /** A CSS font style to be applied to the label text. */
    fontStyle?: string;
    /** A CSS font weight to be applied to the label text. */
    fontWeight?: string;
    /** A transformation to apply to the label text */
    textTransform?: "none" | "uppercase" | "lowercase";
    /** 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. */
    opacity?: number;
    /** 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. */
    zIndex?: number;
    /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
    label?: string;
    /** The animation to apply to the element. example ripple,bounce,etc */
    animation?: object;
    [key: string]: any;
  } & {
    /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
    shape:
      | "ellipse"
      | "triangle"
      | "round-triangle"
      | "rectangle"
      | "round-rectangle"
      | "bottom-round-rectangle"
      | "cut-rectangle"
      | "barrel"
      | "rhomboid"
      | "diamond"
      | "round-diamond"
      | "pentagon"
      | "round-pentagon"
      | "hexagon"
      | "round-hexagon"
      | "concave-hexagon"
      | "heptagon"
      | "round-heptagon"
      | "octagon"
      | "round-octagon"
      | "star"
      | "tag"
      | "round-tag"
      | "vee"
      | "polygon";
    /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
    position?: {
      /** The x-coordinate of the node. */
      x: number;
      /** The y-coordinate of the node. */
      y: number;
    };
    /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
    bodyText?: string;
    /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
    bodyTextWrap?: "none" | "wrap" | "ellipsis";
    /** The maximum width for wrapping text in the node. */
    bodyTextMaxWidth?: string;
    /** The opacity of the node's body text, including its outline. */
    bodyTextOpacity?: number;
    /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
    bodyTextBackgroundColor?: string;
    /** The size of the node's body text. */
    bodyTextFontSize?: number;
    /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
    bodyTextColor?: string;
    /** A CSS font weight to be applied to the node's body text. */
    bodyTextFontWeight?: string;
    /** A CSS horizontal alignment to be applied to the node's body text. */
    bodyTextHorizontalAlign?: string;
    /** A CSS text decoration to be applied to the node's body text. */
    bodyTextDecoration?: string;
    /** A CSS vertical alignment to be applied to the node's body text. */
    bodyTextVerticalAlign?: string;
    /** The width of the node's body or the width of an edge's line. */
    width?: number;
    /** The height of the node's body */
    height?: number;
    /** The URL that points to the image to show in the node. */
    backgroundImage?: string;
    /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
    backgroundColor?: string;
    /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
    backgroundBlacken?: number;
    /** The opacity level of the node's background colour */
    backgroundOpacity?: number;
    /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundPositionX?: string;
    /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundPositionY?: string;
    /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundOffsetX?: string;
    /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundOffsetY?: string;
    /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
    backgroundFit?: "none" | "contain" | "cover";
    /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
    backgroundClip?: "none" | "node" | "node-border";
    /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
    backgroundWidthRelativeTo?: "none" | "inner" | "outer";
    /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
    backgroundHeightRelativeTo?: "none" | "inner" | "outer";
    /** The size of the node's border. */
    borderWidth?: number;
    /** The style of the node's border */
    borderStyle?: "solid" | "dotted" | "dashed" | "double";
    /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
    borderColor?: string;
    /** The opacity of the node's border */
    borderOpacity?: number;
    /** The amount of padding around all sides of the node. */
    padding?: number;
    /** The horizontal alignment of a node's label */
    textHalign?: "left" | "center" | "right";
    /** The vertical alignment of a node's label */
    textValign?: "top" | "center" | "bottom";
    /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
    ghost?: "yes" | "no";
    /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    activeBgColor?: string;
    /** The opacity of the active background indicator. Selector needs to be *core*. */
    activeBgOpacity?: string;
    /** The opacity of the active background indicator. Selector needs to be *core*. */
    activeBgSize?: string;
    /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    selectionBoxColor?: string;
    /** The size of the border on the selection box. Selector needs to be *core* */
    selectionBoxBorderWidth?: number;
    /** The opacity of the selection box. Selector needs to be *core* */
    selectionBoxOpacity?: number;
    /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    outsideTextureBgColor?: string;
    /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
    outsideTextureBgOpacity?: number;
    /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
    shapePolygonPoints?: string;
    /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
    menuBackgroundColor?: string;
    /** The opacity of the background of the component menu. */
    menuBackgroundOpacity?: number;
    /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
    menuForgroundColor?: string;
  };
  /** Connection Status */
  status:
    | "discovered"
    | "registered"
    | "connected"
    | "ignored"
    | "maintenance"
    | "disconnected"
    | "deleted"
    | "not found";
  /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status, along with a description of each transition. */
  transitionMap?: {
    [key: string]: {
      /** Connection Status Value */
      nextState:
        | "discovered"
        | "registered"
        | "connected"
        | "ignored"
        | "maintenance"
        | "disconnected"
        | "deleted"
        | "not found";
      /** Human-readable explanation of when or why this transition occurs. */
      description?: string;
    }[];
  };
  /** User ID who owns this connection */
  owner?: string;
  /** Timestamp when the connection was created. */
  createdAt?: string;
  /** Timestamp when the connection was last updated. */
  updatedAt?: string;
  /** Timestamp when the connection was soft-deleted, if applicable. */
  deletedAt?: string | null;
  /** Associated environments for this connection */
  environments?: {
    /** ID */
    id: string;
    /** Specifies the version of the schema to which the environment conforms. */
    schemaVersion: string;
    /** Environment name */
    name: string;
    /** Environment description */
    description: string;
    /** Environment organization ID */
    organizationId: string;
    /** Environment owner */
    owner?: string;
    /** Timestamp when the environment was created. */
    createdAt?: string;
    /** Additional metadata associated with the environment. */
    metadata?: object;
    /** Timestamp when the environment was last updated. */
    updatedAt?: string;
    /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
    deletedAt?: string | null;
  }[];
  /** Specifies the version of the schema used for the definition. */
  schemaVersion: string;
};
export type GetConnectionByIdApiArg = {
  /** Connection ID */
  connectionId: string;
};
export type UpdateConnectionApiResponse = /** status 200 Connection updated */ {
  /** Connection ID */
  id: string;
  /** Connection Name */
  name: string;
  /** Human-readable description of the connection and its purpose. */
  description?: string;
  /** URL of the remote resource this connection points to (e.g. the Helm repository URL, the Kubernetes API server endpoint, the Grafana instance URL). */
  url?: string;
  /** Associated Credential ID */
  credentialId?: string;
  /** Connection Type (platform, telemetry, collaboration) */
  type: string;
  /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
  subType: string;
  /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
  kind: string;
  /** 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 */
  modelReference?: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    id: string;
    /** The unique name for the model within the scope of a registrant. */
    name: string;
    /** Version of the model definition. */
    version: string;
    /** Human-readable name for the model. */
    displayName: string;
    /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
    model: {
      /** Version of the model as defined by the registrant. */
      version: string;
    };
    registrant: {
      /** Kind of the registrant. */
      kind: string;
    };
  };
  /** Additional connection metadata */
  metadata?: object;
  /** Schema for the credential Associated with the connection */
  credentialSchema?: object;
  /** Schema for the connection */
  connectionSchema?: object;
  /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
  styles?: {
    /** Primary color of the component used for UI representation. */
    primaryColor: string;
    /** Secondary color of the entity used for UI representation. */
    secondaryColor?: string;
    /** White SVG of the entity used for UI representation on dark background. */
    svgWhite: string;
    /** Colored SVG of the entity used for UI representation on light background. */
    svgColor: string;
    /** Complete SVG of the entity used for UI representation, often inclusive of background. */
    svgComplete: string;
    /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
    color?: string;
    /** The opacity of the label text, including its outline. */
    textOpacity?: number;
    /** A comma-separated list of font names to use on the label text. */
    fontFamily?: string;
    /** The size of the label text. */
    fontSize?: string;
    /** A CSS font style to be applied to the label text. */
    fontStyle?: string;
    /** A CSS font weight to be applied to the label text. */
    fontWeight?: string;
    /** A transformation to apply to the label text */
    textTransform?: "none" | "uppercase" | "lowercase";
    /** 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. */
    opacity?: number;
    /** 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. */
    zIndex?: number;
    /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
    label?: string;
    /** The animation to apply to the element. example ripple,bounce,etc */
    animation?: object;
    [key: string]: any;
  } & {
    /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
    shape:
      | "ellipse"
      | "triangle"
      | "round-triangle"
      | "rectangle"
      | "round-rectangle"
      | "bottom-round-rectangle"
      | "cut-rectangle"
      | "barrel"
      | "rhomboid"
      | "diamond"
      | "round-diamond"
      | "pentagon"
      | "round-pentagon"
      | "hexagon"
      | "round-hexagon"
      | "concave-hexagon"
      | "heptagon"
      | "round-heptagon"
      | "octagon"
      | "round-octagon"
      | "star"
      | "tag"
      | "round-tag"
      | "vee"
      | "polygon";
    /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
    position?: {
      /** The x-coordinate of the node. */
      x: number;
      /** The y-coordinate of the node. */
      y: number;
    };
    /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
    bodyText?: string;
    /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
    bodyTextWrap?: "none" | "wrap" | "ellipsis";
    /** The maximum width for wrapping text in the node. */
    bodyTextMaxWidth?: string;
    /** The opacity of the node's body text, including its outline. */
    bodyTextOpacity?: number;
    /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
    bodyTextBackgroundColor?: string;
    /** The size of the node's body text. */
    bodyTextFontSize?: number;
    /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
    bodyTextColor?: string;
    /** A CSS font weight to be applied to the node's body text. */
    bodyTextFontWeight?: string;
    /** A CSS horizontal alignment to be applied to the node's body text. */
    bodyTextHorizontalAlign?: string;
    /** A CSS text decoration to be applied to the node's body text. */
    bodyTextDecoration?: string;
    /** A CSS vertical alignment to be applied to the node's body text. */
    bodyTextVerticalAlign?: string;
    /** The width of the node's body or the width of an edge's line. */
    width?: number;
    /** The height of the node's body */
    height?: number;
    /** The URL that points to the image to show in the node. */
    backgroundImage?: string;
    /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
    backgroundColor?: string;
    /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
    backgroundBlacken?: number;
    /** The opacity level of the node's background colour */
    backgroundOpacity?: number;
    /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundPositionX?: string;
    /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundPositionY?: string;
    /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundOffsetX?: string;
    /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
    backgroundOffsetY?: string;
    /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
    backgroundFit?: "none" | "contain" | "cover";
    /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
    backgroundClip?: "none" | "node" | "node-border";
    /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
    backgroundWidthRelativeTo?: "none" | "inner" | "outer";
    /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
    backgroundHeightRelativeTo?: "none" | "inner" | "outer";
    /** The size of the node's border. */
    borderWidth?: number;
    /** The style of the node's border */
    borderStyle?: "solid" | "dotted" | "dashed" | "double";
    /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
    borderColor?: string;
    /** The opacity of the node's border */
    borderOpacity?: number;
    /** The amount of padding around all sides of the node. */
    padding?: number;
    /** The horizontal alignment of a node's label */
    textHalign?: "left" | "center" | "right";
    /** The vertical alignment of a node's label */
    textValign?: "top" | "center" | "bottom";
    /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
    ghost?: "yes" | "no";
    /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    activeBgColor?: string;
    /** The opacity of the active background indicator. Selector needs to be *core*. */
    activeBgOpacity?: string;
    /** The opacity of the active background indicator. Selector needs to be *core*. */
    activeBgSize?: string;
    /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    selectionBoxColor?: string;
    /** The size of the border on the selection box. Selector needs to be *core* */
    selectionBoxBorderWidth?: number;
    /** The opacity of the selection box. Selector needs to be *core* */
    selectionBoxOpacity?: number;
    /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
    outsideTextureBgColor?: string;
    /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
    outsideTextureBgOpacity?: number;
    /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
    shapePolygonPoints?: string;
    /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
    menuBackgroundColor?: string;
    /** The opacity of the background of the component menu. */
    menuBackgroundOpacity?: number;
    /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
    menuForgroundColor?: string;
  };
  /** Connection Status */
  status:
    | "discovered"
    | "registered"
    | "connected"
    | "ignored"
    | "maintenance"
    | "disconnected"
    | "deleted"
    | "not found";
  /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status, along with a description of each transition. */
  transitionMap?: {
    [key: string]: {
      /** Connection Status Value */
      nextState:
        | "discovered"
        | "registered"
        | "connected"
        | "ignored"
        | "maintenance"
        | "disconnected"
        | "deleted"
        | "not found";
      /** Human-readable explanation of when or why this transition occurs. */
      description?: string;
    }[];
  };
  /** User ID who owns this connection */
  owner?: string;
  /** Timestamp when the connection was created. */
  createdAt?: string;
  /** Timestamp when the connection was last updated. */
  updatedAt?: string;
  /** Timestamp when the connection was soft-deleted, if applicable. */
  deletedAt?: string | null;
  /** Associated environments for this connection */
  environments?: {
    /** ID */
    id: string;
    /** Specifies the version of the schema to which the environment conforms. */
    schemaVersion: string;
    /** Environment name */
    name: string;
    /** Environment description */
    description: string;
    /** Environment organization ID */
    organizationId: string;
    /** Environment owner */
    owner?: string;
    /** Timestamp when the environment was created. */
    createdAt?: string;
    /** Additional metadata associated with the environment. */
    metadata?: object;
    /** Timestamp when the environment was last updated. */
    updatedAt?: string;
    /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
    deletedAt?: string | null;
  }[];
  /** Specifies the version of the schema used for the definition. */
  schemaVersion: string;
};
export type UpdateConnectionApiArg = {
  /** Connection ID */
  connectionId: string;
  body: {
    /** Connection ID */
    id?: string;
    /** Connection name */
    name: string;
    /** Connection kind */
    kind: string;
    /** Connection type */
    type: string;
    /** Connection sub-type */
    subType: string;
    /** Credential secret data */
    credentialSecret?: object;
    /** Connection metadata */
    metadata?: object;
    /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Connection status */
    status: string;
    /** Associated credential ID */
    credentialId?: string;
  };
};
export type DeleteConnectionApiResponse = unknown;
export type DeleteConnectionApiArg = {
  /** Connection ID */
  connectionId: string;
};
export type PerformConnectionActionApiResponse =
  /** status 200 The updated connection after the action was applied. */ {
    /** Connection ID */
    id: string;
    /** Connection Name */
    name: string;
    /** Human-readable description of the connection and its purpose. */
    description?: string;
    /** URL of the remote resource this connection points to (e.g. the Helm repository URL, the Kubernetes API server endpoint, the Grafana instance URL). */
    url?: string;
    /** Associated Credential ID */
    credentialId?: string;
    /** Connection Type (platform, telemetry, collaboration) */
    type: string;
    /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
    subType: string;
    /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
    kind: string;
    /** 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 */
    modelReference?: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Version of the model definition. */
      version: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      registrant: {
        /** Kind of the registrant. */
        kind: string;
      };
    };
    /** Additional connection metadata */
    metadata?: object;
    /** Schema for the credential Associated with the connection */
    credentialSchema?: object;
    /** Schema for the connection */
    connectionSchema?: object;
    /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Connection Status */
    status:
      | "discovered"
      | "registered"
      | "connected"
      | "ignored"
      | "maintenance"
      | "disconnected"
      | "deleted"
      | "not found";
    /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status, along with a description of each transition. */
    transitionMap?: {
      [key: string]: {
        /** Connection Status Value */
        nextState:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** Human-readable explanation of when or why this transition occurs. */
        description?: string;
      }[];
    };
    /** User ID who owns this connection */
    owner?: string;
    /** Timestamp when the connection was created. */
    createdAt?: string;
    /** Timestamp when the connection was last updated. */
    updatedAt?: string;
    /** Timestamp when the connection was soft-deleted, if applicable. */
    deletedAt?: string | null;
    /** Associated environments for this connection */
    environments?: {
      /** ID */
      id: string;
      /** Specifies the version of the schema to which the environment conforms. */
      schemaVersion: string;
      /** Environment name */
      name: string;
      /** Environment description */
      description: string;
      /** Environment organization ID */
      organizationId: string;
      /** Environment owner */
      owner?: string;
      /** Timestamp when the environment was created. */
      createdAt?: string;
      /** Additional metadata associated with the environment. */
      metadata?: object;
      /** Timestamp when the environment was last updated. */
      updatedAt?: string;
      /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
      deletedAt?: string | null;
    }[];
    /** Specifies the version of the schema used for the definition. */
    schemaVersion: string;
  };
export type PerformConnectionActionApiArg = {
  /** Connection ID */
  connectionId: string;
  body: {
    /** The operation to perform on the connection. */
    action: "setMeshsyncMode";
    /** Target MeshSync deployment mode. Required when `action` is `setMeshsyncMode`; the server redeploys MeshSync (operator vs embedded) for the connection's cluster. */
    mode?: "operator" | "embedded";
  };
};
export type DeleteMesheryConnectionApiResponse = unknown;
export type DeleteMesheryConnectionApiArg = {
  /** Meshery server ID */
  mesheryServerId: string;
};
export type GetKubernetesContextApiResponse = /** status 200 Kubernetes context */ {
  /** Zero-based page index returned in this response. */
  page: number;
  /** Maximum number of items returned on each page. */
  pageSize: number;
  /** Total number of items across all pages. */
  totalCount: number;
  /** Kubernetes contexts in this page. */
  contexts: {
    /** Stable identifier of the Kubernetes context, assigned when the context is registered. Not a UUID; carried in connection metadata. */
    id?: string;
    /** Human-readable name of the Kubernetes context. */
    name?: string;
    /** Authentication material for the context (token or kubeconfig reference), sourced from the connection's credential secret. */
    auth?: object;
    /** Cluster definition for the context (certificate authority and server details), sourced from the connection's credential secret. */
    cluster?: object;
    /** API server URL of the Kubernetes cluster. */
    server?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    owner?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    createdBy?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    mesheryInstanceId?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    kubernetesServerId?: string;
    /** How Meshery is deployed relative to the cluster (e.g. in_cluster, out_of_cluster). */
    deploymentType?: string;
    /** Kubernetes server version of the cluster. */
    version?: string;
    /** Timestamp when the underlying connection was created. */
    createdAt?: string;
    /** Timestamp when the underlying connection was last updated. */
    updatedAt?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    connectionId?: string;
    /** Whether this context's API server answered the probe run while its kubeconfig was processed. Discovery and import surface unreachable contexts too, so they can still be registered; reachability only gates the connected transition. */
    reachable?: boolean;
  }[];
};
export type GetKubernetesContextApiArg = {
  /** Connection ID */
  connectionId: string;
};
export type AddConnectionToEnvironmentApiResponse = unknown;
export type AddConnectionToEnvironmentApiArg = {
  /** Environment ID */
  environmentId: string;
  /** Connection ID */
  connectionId: string;
};
export type RemoveConnectionFromEnvironmentApiResponse = unknown;
export type RemoveConnectionFromEnvironmentApiArg = {
  /** Environment ID */
  environmentId: string;
  /** Connection ID */
  connectionId: string;
};
export type ListConnectionDefinitionsApiResponse = /** status 200 Paginated list of connection definitions */ {
  /** List of connection definitions on this page */
  connectionDefinitions: any[];
  /** Total number of connection definitions on all pages */
  totalCount: number;
  /** Current page number */
  page: number;
  /** Number of elements per page */
  pageSize: number;
};
export type ListConnectionDefinitionsApiArg = {
  /** Page number */
  page?: number;
  /** Number of items per page */
  pageSize?: number;
  /** Search term */
  search?: string;
  /** Sort order */
  order?: string;
  /** Filter by the name of the model the connection definition belongs to */
  model?: string;
  /** Filter by connection kind (e.g., kubernetes, prometheus, grafana) */
  kind?: string[];
};
export type RegisterConnectionDefinitionApiResponse = /** status 201 Connection definition registered */ any;
export type RegisterConnectionDefinitionApiArg = {
  body: {
    /** Existing connection definition ID for updates; omit on create. */
    id?: string;
    /** Specifies the version of the schema the definition conforms to. */
    schemaVersion?: string;
    /** Connection definition name */
    name: string;
    /** Human-readable description of the connection definition and its purpose. */
    description?: string;
    /** URL of the remote resource connections of this kind point to. */
    url?: string;
    /** Connection kind (e.g., kubernetes, prometheus, grafana) */
    kind: string;
    /** Connection type (platform, telemetry, collaboration) */
    type: string;
    /** Connection sub-type (cloud, identity, metrics, chat, git, orchestration) */
    subType: string;
    /** Connection Status Value */
    status:
      | "discovered"
      | "registered"
      | "connected"
      | "ignored"
      | "maintenance"
      | "disconnected"
      | "deleted"
      | "not found";
    /** Reference to the registered model that owns this connection definition. */
    modelReference?: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Version of the model definition. */
      version: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      registrant: {
        /** Kind of the registrant. */
        kind: string;
      };
    };
    /** Kind-specific connection metadata */
    metadata?: object;
    /** Schema for the credential associated with connections of this kind. */
    credentialSchema?: object;
    /** Schema for connections of this kind. */
    connectionSchema?: object;
    /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status. */
    transitionMap?: {
      [key: string]: {
        /** Connection Status Value */
        nextState:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** Human-readable explanation of when or why this transition occurs. */
        description?: string;
      }[];
    };
  };
};
export type GetConnectionDefinitionApiResponse = /** status 200 Connection definition details */ any;
export type GetConnectionDefinitionApiArg = {
  /** Connection definition ID */
  connectionDefinitionId: string;
};
export type UpdateConnectionDefinitionApiResponse = /** status 200 Connection definition updated */ any;
export type UpdateConnectionDefinitionApiArg = {
  /** Connection definition ID */
  connectionDefinitionId: string;
  body: {
    /** Existing connection definition ID for updates; omit on create. */
    id?: string;
    /** Specifies the version of the schema the definition conforms to. */
    schemaVersion?: string;
    /** Connection definition name */
    name: string;
    /** Human-readable description of the connection definition and its purpose. */
    description?: string;
    /** URL of the remote resource connections of this kind point to. */
    url?: string;
    /** Connection kind (e.g., kubernetes, prometheus, grafana) */
    kind: string;
    /** Connection type (platform, telemetry, collaboration) */
    type: string;
    /** Connection sub-type (cloud, identity, metrics, chat, git, orchestration) */
    subType: string;
    /** Connection Status Value */
    status:
      | "discovered"
      | "registered"
      | "connected"
      | "ignored"
      | "maintenance"
      | "disconnected"
      | "deleted"
      | "not found";
    /** Reference to the registered model that owns this connection definition. */
    modelReference?: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** The unique name for the model within the scope of a registrant. */
      name: string;
      /** Version of the model definition. */
      version: string;
      /** Human-readable name for the model. */
      displayName: string;
      /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
      model: {
        /** Version of the model as defined by the registrant. */
        version: string;
      };
      registrant: {
        /** Kind of the registrant. */
        kind: string;
      };
    };
    /** Kind-specific connection metadata */
    metadata?: object;
    /** Schema for the credential associated with connections of this kind. */
    credentialSchema?: object;
    /** Schema for connections of this kind. */
    connectionSchema?: object;
    /** Visualization styles for the connection, including svgColor and svgWhite used for UI representation. */
    styles?: {
      /** Primary color of the component used for UI representation. */
      primaryColor: string;
      /** Secondary color of the entity used for UI representation. */
      secondaryColor?: string;
      /** White SVG of the entity used for UI representation on dark background. */
      svgWhite: string;
      /** Colored SVG of the entity used for UI representation on light background. */
      svgColor: string;
      /** Complete SVG of the entity used for UI representation, often inclusive of background. */
      svgComplete: string;
      /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
      color?: string;
      /** The opacity of the label text, including its outline. */
      textOpacity?: number;
      /** A comma-separated list of font names to use on the label text. */
      fontFamily?: string;
      /** The size of the label text. */
      fontSize?: string;
      /** A CSS font style to be applied to the label text. */
      fontStyle?: string;
      /** A CSS font weight to be applied to the label text. */
      fontWeight?: string;
      /** A transformation to apply to the label text */
      textTransform?: "none" | "uppercase" | "lowercase";
      /** 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. */
      opacity?: number;
      /** 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. */
      zIndex?: number;
      /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
      label?: string;
      /** The animation to apply to the element. example ripple,bounce,etc */
      animation?: object;
      [key: string]: any;
    } & {
      /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
      shape:
        | "ellipse"
        | "triangle"
        | "round-triangle"
        | "rectangle"
        | "round-rectangle"
        | "bottom-round-rectangle"
        | "cut-rectangle"
        | "barrel"
        | "rhomboid"
        | "diamond"
        | "round-diamond"
        | "pentagon"
        | "round-pentagon"
        | "hexagon"
        | "round-hexagon"
        | "concave-hexagon"
        | "heptagon"
        | "round-heptagon"
        | "octagon"
        | "round-octagon"
        | "star"
        | "tag"
        | "round-tag"
        | "vee"
        | "polygon";
      /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
      position?: {
        /** The x-coordinate of the node. */
        x: number;
        /** The y-coordinate of the node. */
        y: number;
      };
      /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
      bodyText?: string;
      /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
      bodyTextWrap?: "none" | "wrap" | "ellipsis";
      /** The maximum width for wrapping text in the node. */
      bodyTextMaxWidth?: string;
      /** The opacity of the node's body text, including its outline. */
      bodyTextOpacity?: number;
      /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextBackgroundColor?: string;
      /** The size of the node's body text. */
      bodyTextFontSize?: number;
      /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
      bodyTextColor?: string;
      /** A CSS font weight to be applied to the node's body text. */
      bodyTextFontWeight?: string;
      /** A CSS horizontal alignment to be applied to the node's body text. */
      bodyTextHorizontalAlign?: string;
      /** A CSS text decoration to be applied to the node's body text. */
      bodyTextDecoration?: string;
      /** A CSS vertical alignment to be applied to the node's body text. */
      bodyTextVerticalAlign?: string;
      /** The width of the node's body or the width of an edge's line. */
      width?: number;
      /** The height of the node's body */
      height?: number;
      /** The URL that points to the image to show in the node. */
      backgroundImage?: string;
      /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
      backgroundColor?: string;
      /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
      backgroundBlacken?: number;
      /** The opacity level of the node's background colour */
      backgroundOpacity?: number;
      /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionX?: string;
      /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundPositionY?: string;
      /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetX?: string;
      /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
      backgroundOffsetY?: string;
      /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
      backgroundFit?: "none" | "contain" | "cover";
      /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
      backgroundClip?: "none" | "node" | "node-border";
      /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundWidthRelativeTo?: "none" | "inner" | "outer";
      /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
      backgroundHeightRelativeTo?: "none" | "inner" | "outer";
      /** The size of the node's border. */
      borderWidth?: number;
      /** The style of the node's border */
      borderStyle?: "solid" | "dotted" | "dashed" | "double";
      /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
      borderColor?: string;
      /** The opacity of the node's border */
      borderOpacity?: number;
      /** The amount of padding around all sides of the node. */
      padding?: number;
      /** The horizontal alignment of a node's label */
      textHalign?: "left" | "center" | "right";
      /** The vertical alignment of a node's label */
      textValign?: "top" | "center" | "bottom";
      /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
      ghost?: "yes" | "no";
      /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      activeBgColor?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgOpacity?: string;
      /** The opacity of the active background indicator. Selector needs to be *core*. */
      activeBgSize?: string;
      /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      selectionBoxColor?: string;
      /** The size of the border on the selection box. Selector needs to be *core* */
      selectionBoxBorderWidth?: number;
      /** The opacity of the selection box. Selector needs to be *core* */
      selectionBoxOpacity?: number;
      /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
      outsideTextureBgColor?: string;
      /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
      outsideTextureBgOpacity?: number;
      /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
      shapePolygonPoints?: string;
      /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuBackgroundColor?: string;
      /** The opacity of the background of the component menu. */
      menuBackgroundOpacity?: number;
      /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
      menuForgroundColor?: string;
    };
    /** Map describing the connection state machine. Each key is a current connection status and its value is the list of states the connection may transition to from that status. */
    transitionMap?: {
      [key: string]: {
        /** Connection Status Value */
        nextState:
          | "discovered"
          | "registered"
          | "connected"
          | "ignored"
          | "maintenance"
          | "disconnected"
          | "deleted"
          | "not found";
        /** Human-readable explanation of when or why this transition occurs. */
        description?: string;
      }[];
    };
  };
};
export type DeleteConnectionDefinitionApiResponse = unknown;
export type DeleteConnectionDefinitionApiArg = {
  /** Connection definition ID */
  connectionDefinitionId: string;
};
export type ImportDesignApiResponse =
  /** status 200 Successful import. The response body is a JSON array of the saved designs, not a message envelope. The import path saves exactly one design, so the array carries a single element and consumers read the imported design as the first element. */ {
    /** Server-generated design ID. */
    id?: string;
    /** Human-readable design name. */
    name?: string;
    /** Catalog metadata attached to the design when published. */
    catalogData?: {
      /** Tracks the specific content version that has been made available in the Catalog. */
      publishedVersion?: string;
      /** Published content is classifed by its support level. Content classes help you understand the origin and expected support level for each piece of content. It is important to note that the level of support may vary within each class, and you should exercise discretion when using community-contributed content. Content produced and fully supported by Meshery maintainers. This represents the highest level of support and is considered the most reliable. Content produced by partners and verified by Meshery maintainers. While not directly maintained by Meshery, it has undergone a verification process to ensure quality and compatibility. Content produced and supported by the respective project or organization responsible for the specific technology. This class offers a level of support from the project maintainers themselves. Content produced and shared by Meshery users. This includes a wide range of content, such as performance profiles, test results, filters, patterns, and applications. Community content may have varying levels of support and reliability. */
      class?: "official" | "verified" | "reference architecture";
      /** One or more models associated with this catalog item. For designs, a list of one or more models implicated by components within the design. For models, this is self-referential. */
      compatibility: "kubernetes"[];
      /** Specific stipulations to consider and known behaviors to be aware of when using this design. */
      patternCaveats: string;
      /** Purpose of the design along with its intended and unintended uses. */
      patternInfo: string;
      /** Categorization of the type of design or operational flow depicted in this design. */
      type:
        | "Deployment"
        | "Observability"
        | "Resiliency"
        | "Scaling"
        | "Security"
        | "Traffic-management"
        | "Troubleshooting"
        | "Workloads";
      /** Contains reference to the dark and light mode snapshots of the design. */
      snapshotURL?: string[];
    };
    /** Owning user ID. */
    userId?: string;
    /** Owning user record, joined inline by the catalog list/get handlers when shaping responses. Server-projected from the users table via the design's userId; not a column on the meshery_patterns table itself, so the generated Go field is tagged `db:"-"` to keep it out of ORM column scans.
     */
    user?: {
      /** Unique identifier for the user */
      id: string;
      /** Legacy IdP-derived identifier. Removed in v1beta3; resolve users by id or email. */
      userId: string;
      /** Authentication provider (e.g., Google, Github) */
      provider: string;
      /** User's email address */
      email: string;
      /** User's first name */
      firstName: string;
      /** User's last name */
      lastName: string;
      /** URL to user's avatar image */
      avatarUrl?: string;
      /** User account status */
      status: "active" | "inactive" | "pending" | "anonymous";
      /** User's biography or description */
      bio?: string;
      /** User's country information stored as JSONB */
      country?: {
        [key: string]: any;
      };
      /** User's region information stored as JSONB */
      region?: {
        [key: string]: any;
      };
      /** User preferences stored as JSONB */
      preferences?: {
        /** The mesh adapters of the preference. */
        meshAdapters?: object[];
        grafana?: {
          /** Grafana URL for the user configuration. */
          grafanaUrl?: string;
          /** Grafana API key for the user configuration. */
          grafanaApiKey?: string;
          /** Selected Grafana board configurations for the user. */
          selectedBoardsConfigs?: {
            /** Placeholder for GrafanaBoard definition (define fields as needed) */
            board?: object;
            /** Panels selected for the Grafana board configuration. */
            panels?: object[];
            /** Template variables applied to the selected Grafana board configuration. */
            templateVars?: string[];
          }[];
        };
        prometheus?: {
          /** The prometheus URL of the prometheus. */
          prometheusUrl?: string;
          /** The selected prometheus boards configs of the prometheus. */
          selectedPrometheusBoardsConfigs?: {
            /** Placeholder for GrafanaBoard definition (define fields as needed) */
            board?: object;
            /** Panels selected for the Grafana board configuration. */
            panels?: object[];
            /** Template variables applied to the selected Grafana board configuration. */
            templateVars?: string[];
          }[];
        };
        loadTestPrefs?: {
          /** Concurrent requests */
          c?: number;
          /** Queries per second */
          qps?: number;
          /** Duration */
          t?: string;
          /** Load generator */
          gen?: string;
        };
        /** The anonymous usage stats of the preference. */
        anonymousUsageStats: boolean;
        /** The anonymous perf results of the preference. */
        anonymousPerfResults: boolean;
        /** Timestamp of when the resource was last updated. */
        updatedAt: string;
        /** The dashboard preferences of the preference. */
        dashboardPreferences: {
          [key: string]: any;
        };
        /** ID of the associated selectedOrganization. */
        selectedOrganizationId: string;
        /** The selected workspace for organizations of the preference. */
        selectedWorkspaceForOrganizations: {
          [key: string]: string;
        };
        /** The users extension preferences of the preference. */
        usersExtensionPreferences: {
          [key: string]: any;
        };
        /** The remote provider preferences of the preference. */
        remoteProviderPreferences: {
          [key: string]: any;
        };
      };
      /** Timestamp when user accepted terms and conditions */
      acceptedTermsAt?: string;
      /** Timestamp of user's first login */
      firstLoginTime?: string;
      /** Timestamp of user's most recent login */
      lastLoginTime: string;
      /** Timestamp when the user record was created */
      createdAt: string;
      /** Timestamp when the user record was last updated */
      updatedAt: string;
      /** Various online profiles associated with the user account */
      socials?: {
        /** The site of the social. */
        site: string;
        /** The link of the social. */
        link: string;
      }[];
      /** Timestamp when the user record was soft-deleted (null if not deleted) */
      deletedAt: string | null;
      /** Names of the global roles assigned to the user. Free-form, user-generated values sourced from the roles table (role_name is a varchar, not a fixed enumeration); the seeded system roles such as "admin", "organization admin" and "user" are a subset, not the whole set. */
      roleNames?: string[];
      /** Teams the user belongs to with role information */
      teams?: {
        /** Team memberships for the user with their assigned roles. */
        teamsWithRoles?: {
          /** Unique identifier of the team. */
          id: string;
          /** Name of the team. */
          name: string;
          /** Human readable description of the team. */
          description?: string;
          /** Identifier of the team owner. */
          owner?: string;
          /** Free-form metadata associated with the team. */
          metadata?: {
            [key: string]: any;
          };
          /** Timestamp when the team was created. */
          createdAt?: string;
          /** Timestamp when the team was last updated. */
          updatedAt?: string;
          /** Timestamp when the team was soft-deleted (null if not deleted). */
          deletedAt?: string | null;
          /** Names of the roles assigned to the user within this team. Free-form, user-generated role names; not a fixed enumeration. */
          roleNames: string[];
        }[];
        /** Total number of team memberships returned for the user. */
        totalCount?: number;
      };
      /** Organizations the user belongs to with role information */
      organizations?: {
        /** Organization memberships for the user with their assigned roles. */
        organizationsWithRoles?: {
          /** Unique identifier of the organization. */
          id: string;
          /** Name of the organization. */
          name: string;
          /** Human readable description of the organization. */
          description?: string;
          /** Country associated with the organization. */
          country?: string;
          /** Region associated with the organization. */
          region?: string;
          /** Identifier of the organization owner. */
          owner?: string;
          /** Timestamp when the organization was created. */
          createdAt?: string;
          /** Timestamp when the organization was last updated. */
          updatedAt?: string;
          /** Timestamp when the organization was soft-deleted (null if not deleted). */
          deletedAt?: string | null;
          /** Names of the roles assigned to the user within this organization. Free-form, user-generated role names; not a fixed enumeration. */
          roleNames: string[];
        }[];
        /** Total number of organization memberships returned for the user. */
        totalCount?: number;
      };
    } | null;
    /** Optional structured location metadata (branch, host, path, ...). */
    location?: {
      [key: string]: string;
    };
    /** Raw design body as it is persisted in the meshery_patterns table's `pattern_file` column. The wire form is the YAML/JSON string the server stores verbatim; consumers that need the structured form transcode at the boundary by parsing the string into a PatternFile (see #/components/schemas/PatternFile) and marshalling it back when they write. Keeping the wire shape as a string mirrors the column's actual representation and avoids forcing every consumer through the structured-vs- string union that the previous *PatternFile typing implied.
     */
    patternFile?: string;
    /** Visibility scope of the design — controls whether non-owners may read or list it. `private` is owner-only, `public` is readable by anyone in the org, and `published` is visible in the catalog.
     */
    visibility?: "private" | "public" | "published";
    /** Discriminator identifying the source format of the design body, persisted in the meshery_patterns table's `source_type` column (nullable; null for legacy rows imported before the column was introduced). For catalog listings the server may also project this field from the attached catalog metadata. Use this field to branch rendering between native Meshery designs and imported Helm charts, Kubernetes manifests, and Docker Compose files.
     */
    designType?: ("Design" | "Helm Chart" | "Docker Compose" | "Kubernetes Manifest") | null;
    /** Raw bytes of the imported source artifact (Helm chart tarball, Kubernetes manifest, Docker Compose file, etc.) preserved in the meshery_patterns table's `source_content` column for non-Meshery-Design imports. Empty / null for native Meshery designs. Server-managed: populated by the import and upload handlers and scrubbed to null on most read responses, so clients should treat this as opaque base64-encoded bytes when it does appear on the wire.
     */
    sourceContent?: string | null;
    /** Server-aggregated count of views on this design in the catalog. Present on list/catalog responses; server-managed and ignored on writes.
     */
    viewCount?: number;
    /** Server-aggregated count of downloads of this design from the catalog. Server-managed and ignored on writes.
     */
    downloadCount?: number;
    /** Server-aggregated count of times this design has been cloned from the catalog. Server-managed and ignored on writes.
     */
    cloneCount?: number;
    /** Server-aggregated count of deployments originated from this design. Server-managed and ignored on writes.
     */
    deploymentCount?: number;
    /** Server-aggregated count of share events for this design. Server-managed and ignored on writes.
     */
    shareCount?: number;
    /** Timestamp of design creation. */
    createdAt?: string;
    /** Timestamp of last design modification. */
    updatedAt?: string;
  }[];
export type ImportDesignApiArg = {
  body:
    | {
        /** Base64-encoded file bytes. Supported formats: Kubernetes Manifests, Helm Charts, Docker Compose, and Meshery Designs. See [Import Designs Documentation](https://docs.meshery.io/guides/configuration-management/importing-designs#import-designs-using-meshery-ui) for details. */
        file: string;
        /** The name of the pattern file being imported. Include the extension (e.g. `design.yaml`), as the server uses it to identify the file type. */
        fileName: string;
        /** Provide a name for your design. This name will help you identify the design later. You can also change the name of your design after importing it. */
        name?: string;
      }
    | {
        /** A direct URL to a single file, for example: https://raw.github.com/your-design-file.yaml. Ensure the resource is in a supported format: Kubernetes Manifest, Helm Chart, Docker Compose, or Meshery Design. See [Import Designs Documentation](https://docs.meshery.io/guides/configuration-management/importing-designs#import-designs-using-meshery-ui) for details. */
        url: string;
        /** Provide a name for your design. This name will help you identify the design later. You can also change the name of your design after importing it. */
        name?: string;
      };
};
export type CreateEnvironmentApiResponse = /** status 201 Created environment */ {
  /** ID */
  id: string;
  /** Specifies the version of the schema to which the environment conforms. */
  schemaVersion: string;
  /** Environment name */
  name: string;
  /** Environment description */
  description: string;
  /** Environment organization ID */
  organizationId: string;
  /** Environment owner */
  owner?: string;
  /** Timestamp when the environment was created. */
  createdAt?: string;
  /** Additional metadata associated with the environment. */
  metadata?: object;
  /** Timestamp when the environment was last updated. */
  updatedAt?: string;
  /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
  deletedAt?: string | null;
};
export type CreateEnvironmentApiArg = {
  /** Body for creating environment */
  body: {
    /** An environment is a collection of resources. Provide a name that meaningfully represents these resources. You can change the name of the environment even after its creation. */
    name: string;
    /** An environment is a collection of resources, such as connections & credentials. Provide a detailed description to clarify the purpose of this environment and the types of resources it encompasses. You can modify the description at any time. Learn more about environments [here](https://docs.meshery.io/concepts/logical/environments). */
    description?: string;
    /** Select an organization in which you want to create this new environment. Keep in mind that the organization cannot be changed after creation. */
    organizationId: string;
  };
};
export type GetEnvironmentsApiResponse = /** status 200 Environments */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Environments associated with this resource. */
  environments?: {
    /** ID */
    id: string;
    /** Specifies the version of the schema to which the environment conforms. */
    schemaVersion: string;
    /** Environment name */
    name: string;
    /** Environment description */
    description: string;
    /** Environment organization ID */
    organizationId: string;
    /** Environment owner */
    owner?: string;
    /** Timestamp when the environment was created. */
    createdAt?: string;
    /** Additional metadata associated with the environment. */
    metadata?: object;
    /** Timestamp when the environment was last updated. */
    updatedAt?: string;
    /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
    deletedAt?: string | null;
  }[];
};
export type GetEnvironmentsApiArg = {
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
  /** User's organization ID */
  orgId: string;
};
export type GetEnvironmentByIdApiResponse = /** status 200 Environment page */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Environments associated with this resource. */
  environments?: {
    /** ID */
    id: string;
    /** Specifies the version of the schema to which the environment conforms. */
    schemaVersion: string;
    /** Environment name */
    name: string;
    /** Environment description */
    description: string;
    /** Environment organization ID */
    organizationId: string;
    /** Environment owner */
    owner?: string;
    /** Timestamp when the environment was created. */
    createdAt?: string;
    /** Additional metadata associated with the environment. */
    metadata?: object;
    /** Timestamp when the environment was last updated. */
    updatedAt?: string;
    /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
    deletedAt?: string | null;
  }[];
};
export type GetEnvironmentByIdApiArg = {
  /** Environment ID */
  environmentId: string;
  /** User's organization ID */
  orgId: string;
};
export type UpdateEnvironmentApiResponse = /** status 200 Environment page */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Environments associated with this resource. */
  environments?: {
    /** ID */
    id: string;
    /** Specifies the version of the schema to which the environment conforms. */
    schemaVersion: string;
    /** Environment name */
    name: string;
    /** Environment description */
    description: string;
    /** Environment organization ID */
    organizationId: string;
    /** Environment owner */
    owner?: string;
    /** Timestamp when the environment was created. */
    createdAt?: string;
    /** Additional metadata associated with the environment. */
    metadata?: object;
    /** Timestamp when the environment was last updated. */
    updatedAt?: string;
    /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
    deletedAt?: string | null;
  }[];
};
export type UpdateEnvironmentApiArg = {
  /** Environment ID */
  environmentId: string;
  /** Body for creating environment */
  body: {
    /** An environment is a collection of resources. Provide a name that meaningfully represents these resources. You can change the name of the environment even after its creation. */
    name: string;
    /** An environment is a collection of resources, such as connections & credentials. Provide a detailed description to clarify the purpose of this environment and the types of resources it encompasses. You can modify the description at any time. Learn more about environments [here](https://docs.meshery.io/concepts/logical/environments). */
    description?: string;
    /** Select an organization in which you want to create this new environment. Keep in mind that the organization cannot be changed after creation. */
    organizationId: string;
  };
};
export type DeleteEnvironmentApiResponse = unknown;
export type DeleteEnvironmentApiArg = {
  /** Environment ID */
  environmentId: string;
};
export type GetEnvironmentConnectionsApiResponse = /** status 200 Environment connections */ {
  /** Current page number of the result set. */
  page?: number;
  /** Number of items per page. */
  pageSize?: number;
  /** Total number of items available. */
  totalCount?: number;
  /** The connections of the environmentconnectionspage. */
  connections?: {
    [key: string]: any;
  }[];
};
export type GetEnvironmentConnectionsApiArg = {
  /** Environment ID */
  environmentId: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
  /** JSON-encoded filter string used to scope the connection listing. */
  filter?: string;
};
export type DeleteEventApiResponse = unknown;
export type DeleteEventApiArg = {
  /** ID of the event. */
  eventId: string;
};
export type BulkDeleteEventsApiResponse = /** status 200 Events deleted */ {
  /** UUIDs of events that were deleted. */
  deleted?: string[];
};
export type BulkDeleteEventsApiArg = {
  body: {
    /** UUIDs of the events to delete. */
    ids: string[];
  };
};
export type BulkUpdateEventStatusApiResponse = /** status 200 Events updated */ {
  /** UUIDs of events whose status was updated. */
  updated?: string[];
};
export type BulkUpdateEventStatusApiArg = {
  body: {
    /** UUIDs of the events to update. */
    ids: string[];
    /** New status to apply to the selected events. */
    status: string;
  };
};
export type UpdateEventStatusApiResponse = /** status 200 Event status updated */ {
  /** Human-readable status message. */
  message?: string;
  /** UUID of the event whose status was updated. */
  eventId?: string;
  /** Updated status of the event. */
  status?: string;
};
export type UpdateEventStatusApiArg = {
  /** ID of the event. */
  eventId: string;
  body: {
    /** Current status of the event. */
    status: string;
  };
};
export type CreateEventApiResponse = unknown;
export type CreateEventApiArg = {
  body: {
    /** UUID of the user associated with the event. */
    owner?: string;
    /** The category of the event. */
    category?: string;
    /** The action of the event. */
    action?: string;
    /** Description of the event. */
    description?: string;
    [key: string]: any;
  };
};
export type GetPerformanceProfilesApiResponse = /** status 200 Performance profiles */ {
  /** Zero-based page index returned in this response. */
  page: number;
  /** Maximum number of items returned on each page. */
  pageSize: number;
  /** Total number of performance profiles across all pages. */
  totalCount: number;
  /** Performance profiles in this page. */
  profiles: {
    /** Unique identifier for the performance profile. */
    id: string;
    /** Human-readable name of the performance profile. */
    name: string;
    /** User ID of the profile owner. */
    owner: string;
    /** Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule. */
    schedule?: string | null;
    /** Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
    loadGenerators?: string[];
    /** Endpoints (URLs) targeted by the performance profile's load test. */
    endpoints?: string[];
    /** Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
    serviceMesh?: string;
    /** Number of concurrent requests issued by the load generator. */
    concurrentRequest?: number;
    /** Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
    qps?: number;
    /** Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
    duration?: string;
    /** HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
    requestHeaders?: string;
    /** HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
    requestCookies?: string;
    /** HTTP request body sent on each load-test request. Empty string when no body is configured. */
    requestBody?: string;
    /** Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
    contentType?: string;
    /** Free-form metadata associated with the performance profile. */
    metadata?: {
      [key: string]: any;
    };
    /** Server-computed timestamp of the most recent load-test run that used this profile. Null until the first run completes. Server-managed; clients must not set this on create/update. */
    lastRun?: string | null;
    /** Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
    totalResults?: number;
    /** Timestamp when the performance profile was created. */
    createdAt: string;
    /** Timestamp when the performance profile was last updated. */
    updatedAt: string;
  }[];
};
export type GetPerformanceProfilesApiArg = {
  /** Get responses by page */
  page?: number;
  /** Get responses by pagesize */
  pagesize?: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
};
export type UpsertPerformanceProfileApiResponse = /** status 200 Performance profile upserted */ {
  /** Unique identifier for the performance profile. */
  id: string;
  /** Human-readable name of the performance profile. */
  name: string;
  /** User ID of the profile owner. */
  owner: string;
  /** Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule. */
  schedule?: string | null;
  /** Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
  loadGenerators?: string[];
  /** Endpoints (URLs) targeted by the performance profile's load test. */
  endpoints?: string[];
  /** Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
  serviceMesh?: string;
  /** Number of concurrent requests issued by the load generator. */
  concurrentRequest?: number;
  /** Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
  qps?: number;
  /** Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
  duration?: string;
  /** HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
  requestHeaders?: string;
  /** HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
  requestCookies?: string;
  /** HTTP request body sent on each load-test request. Empty string when no body is configured. */
  requestBody?: string;
  /** Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
  contentType?: string;
  /** Free-form metadata associated with the performance profile. */
  metadata?: {
    [key: string]: any;
  };
  /** Server-computed timestamp of the most recent load-test run that used this profile. Null until the first run completes. Server-managed; clients must not set this on create/update. */
  lastRun?: string | null;
  /** Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
  totalResults?: number;
  /** Timestamp when the performance profile was created. */
  createdAt: string;
  /** Timestamp when the performance profile was last updated. */
  updatedAt: string;
};
export type UpsertPerformanceProfileApiArg = {
  /** Body for creating or updating a performance profile. */
  body: {
    /** Existing performance-profile ID for updates; omit on create. */
    id?: string;
    /** Human-readable name of the performance profile. */
    name: string;
    /** Owner user ID. When omitted, the server infers it from the authenticated user. */
    owner?: string;
    /** Optional schedule ID associating the profile with a recurring run. */
    schedule?: string | null;
    /** Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
    loadGenerators: string[];
    /** Endpoints (URLs) targeted by the performance profile's load test. */
    endpoints: string[];
    /** Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
    serviceMesh?: string;
    /** Number of concurrent requests issued by the load generator. */
    concurrentRequest?: number;
    /** Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
    qps?: number;
    /** Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
    duration: string;
    /** HTTP request headers, serialized as JSON, sent on each load-test request. */
    requestHeaders?: string;
    /** HTTP request cookies, serialized as JSON, sent on each load-test request. */
    requestCookies?: string;
    /** HTTP request body sent on each load-test request. */
    requestBody?: string;
    /** Content-Type header value applied to each load-test request body (e.g. "application/json"). */
    contentType?: string;
    /** Free-form metadata associated with the performance profile. */
    metadata?: {
      [key: string]: any;
    };
  };
};
export type GetPerformanceProfileApiResponse = /** status 200 Performance profile */ {
  /** Unique identifier for the performance profile. */
  id: string;
  /** Human-readable name of the performance profile. */
  name: string;
  /** User ID of the profile owner. */
  owner: string;
  /** Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule. */
  schedule?: string | null;
  /** Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
  loadGenerators?: string[];
  /** Endpoints (URLs) targeted by the performance profile's load test. */
  endpoints?: string[];
  /** Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
  serviceMesh?: string;
  /** Number of concurrent requests issued by the load generator. */
  concurrentRequest?: number;
  /** Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
  qps?: number;
  /** Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
  duration?: string;
  /** HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
  requestHeaders?: string;
  /** HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
  requestCookies?: string;
  /** HTTP request body sent on each load-test request. Empty string when no body is configured. */
  requestBody?: string;
  /** Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
  contentType?: string;
  /** Free-form metadata associated with the performance profile. */
  metadata?: {
    [key: string]: any;
  };
  /** Server-computed timestamp of the most recent load-test run that used this profile. Null until the first run completes. Server-managed; clients must not set this on create/update. */
  lastRun?: string | null;
  /** Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
  totalResults?: number;
  /** Timestamp when the performance profile was created. */
  createdAt: string;
  /** Timestamp when the performance profile was last updated. */
  updatedAt: string;
};
export type GetPerformanceProfileApiArg = {
  /** Performance profile ID. */
  performanceProfileId: string;
};
export type UpdatePerformanceProfileApiResponse = /** status 200 Performance profile */ {
  /** Unique identifier for the performance profile. */
  id: string;
  /** Human-readable name of the performance profile. */
  name: string;
  /** User ID of the profile owner. */
  owner: string;
  /** Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule. */
  schedule?: string | null;
  /** Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
  loadGenerators?: string[];
  /** Endpoints (URLs) targeted by the performance profile's load test. */
  endpoints?: string[];
  /** Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
  serviceMesh?: string;
  /** Number of concurrent requests issued by the load generator. */
  concurrentRequest?: number;
  /** Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
  qps?: number;
  /** Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
  duration?: string;
  /** HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
  requestHeaders?: string;
  /** HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
  requestCookies?: string;
  /** HTTP request body sent on each load-test request. Empty string when no body is configured. */
  requestBody?: string;
  /** Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
  contentType?: string;
  /** Free-form metadata associated with the performance profile. */
  metadata?: {
    [key: string]: any;
  };
  /** Server-computed timestamp of the most recent load-test run that used this profile. Null until the first run completes. Server-managed; clients must not set this on create/update. */
  lastRun?: string | null;
  /** Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
  totalResults?: number;
  /** Timestamp when the performance profile was created. */
  createdAt: string;
  /** Timestamp when the performance profile was last updated. */
  updatedAt: string;
};
export type UpdatePerformanceProfileApiArg = {
  /** Performance profile ID. */
  performanceProfileId: string;
  /** Body for creating or updating a performance profile. */
  body: {
    /** Existing performance-profile ID for updates; omit on create. */
    id?: string;
    /** Human-readable name of the performance profile. */
    name: string;
    /** Owner user ID. When omitted, the server infers it from the authenticated user. */
    owner?: string;
    /** Optional schedule ID associating the profile with a recurring run. */
    schedule?: string | null;
    /** Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
    loadGenerators: string[];
    /** Endpoints (URLs) targeted by the performance profile's load test. */
    endpoints: string[];
    /** Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
    serviceMesh?: string;
    /** Number of concurrent requests issued by the load generator. */
    concurrentRequest?: number;
    /** Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
    qps?: number;
    /** Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
    duration: string;
    /** HTTP request headers, serialized as JSON, sent on each load-test request. */
    requestHeaders?: string;
    /** HTTP request cookies, serialized as JSON, sent on each load-test request. */
    requestCookies?: string;
    /** HTTP request body sent on each load-test request. */
    requestBody?: string;
    /** Content-Type header value applied to each load-test request body (e.g. "application/json"). */
    contentType?: string;
    /** Free-form metadata associated with the performance profile. */
    metadata?: {
      [key: string]: any;
    };
  };
};
export type DeletePerformanceProfileApiResponse = unknown;
export type DeletePerformanceProfileApiArg = {
  /** Performance profile ID. */
  performanceProfileId: string;
};
export type GetPerformanceProfileResultsApiResponse = /** status 200 Performance results */ {
  /** Zero-based page index returned in this response. */
  page: number;
  /** Maximum number of items returned on each page. */
  pageSize: number;
  /** Total number of performance results across all pages. */
  totalCount: number;
  /** Performance results in this page. */
  results: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    mesheryId?: string;
    /** Human-readable name of the performance result. */
    name?: string;
    /** Service mesh under test for this result. */
    mesh?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    performanceProfile?: string | null;
    /** Provider-assigned test identifier for this result. */
    testId?: string;
    /** Raw load-generator output for this performance result. */
    runnerResults?: {
      [key: string]: any;
    };
    /** Server-side metrics collected for this performance result. */
    serverMetrics?: {
      [key: string]: any;
    };
    /** Server board configuration associated with this performance result. */
    serverBoardConfig?: {
      [key: string]: any;
    };
    /** Time when the load test started. */
    testStartTime?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    owner?: string;
    /** Timestamp when the performance result was created. */
    createdAt?: string;
    /** Timestamp when the performance result was last updated. */
    updatedAt?: string;
  }[];
};
export type GetPerformanceProfileResultsApiArg = {
  /** Performance profile ID. */
  performanceProfileId: string;
  /** Get responses by page */
  page?: number;
  /** Get responses by pagesize */
  pagesize?: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
};
export type GetPerformanceResultsApiResponse = /** status 200 Performance results */ {
  /** Zero-based page index returned in this response. */
  page: number;
  /** Maximum number of items returned on each page. */
  pageSize: number;
  /** Total number of performance results across all pages. */
  totalCount: number;
  /** Performance results in this page. */
  results: {
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    mesheryId?: string;
    /** Human-readable name of the performance result. */
    name?: string;
    /** Service mesh under test for this result. */
    mesh?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    performanceProfile?: string | null;
    /** Provider-assigned test identifier for this result. */
    testId?: string;
    /** Raw load-generator output for this performance result. */
    runnerResults?: {
      [key: string]: any;
    };
    /** Server-side metrics collected for this performance result. */
    serverMetrics?: {
      [key: string]: any;
    };
    /** Server board configuration associated with this performance result. */
    serverBoardConfig?: {
      [key: string]: any;
    };
    /** Time when the load test started. */
    testStartTime?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    owner?: string;
    /** Timestamp when the performance result was created. */
    createdAt?: string;
    /** Timestamp when the performance result was last updated. */
    updatedAt?: string;
  }[];
};
export type GetPerformanceResultsApiArg = {
  /** Get responses by page */
  page?: number;
  /** Get responses by pagesize */
  pagesize?: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Start date for filtering results by test start time, in YYYY-MM-DD format. */
  from?: string;
  /** End date for filtering results by test start time, in YYYY-MM-DD format. */
  to?: string;
};
export type GetUsersApiResponse = /** status 200 Paginated list of public users */ {
  /** Current page number of the result set. */
  page: number;
  /** Number of items per page. */
  pageSize: number;
  /** Total number of items available. */
  totalCount: number;
  /** Public user records for the requested page. */
  data: {
    /** Unique identifier for the user */
    id: string;
    /** Deprecated duplicate of id kept for consumers that predate the retirement of the legacy user_id column; always equals id. */
    userId?: string;
    /** Public username of the user */
    username?: string;
    /** URL to user's avatar image */
    avatarUrl?: string;
  }[];
};
export type GetUsersApiArg = {
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get filtered reponses */
  filter?: string;
};
export type SearchUsersApiResponse = /** status 200 Paginated list of matching users in the searchable projection */ {
  /** Current page number of the result set. */
  page: number;
  /** Number of items per page. */
  pageSize: number;
  /** Total number of items available. */
  totalCount: number;
  /** Matching user records for the requested page. */
  data: {
    /** Unique identifier for the user */
    id: string;
    /** Deprecated duplicate of id kept for consumers that predate the retirement of the legacy user_id column; always equals id. */
    userId?: string;
    /** Public username of the user */
    username?: string;
    /** User's first name */
    firstName?: string;
    /** User's last name */
    lastName?: string;
    /** User's email address */
    email?: string;
    /** URL to user's avatar image */
    avatarUrl?: string;
    /** Timestamp when the user record was soft-deleted (null if not deleted) */
    deletedAt?: string | null;
  }[];
};
export type SearchUsersApiArg = {
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get filtered reponses */
  filter?: string;
};
export type GetWorkspacesApiResponse = /** status 200 Workspaces */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** List of workspaces with resolved owner details. */
  workspaces?: {
    id?: string;
    /** Name of the workspace. */
    name?: string;
    /** Description of the workspace. */
    description?: string;
    /** Name of the owning organization. */
    orgName?: string;
    /** Display name of the workspace owner. */
    owner?: string;
    /** User ID of the workspace owner. */
    ownerId?: string;
    /** Email address of the workspace owner. */
    ownerEmail?: string;
    /** Avatar URL of the workspace owner. */
    ownerAvatar?: string;
    /** Metadata associated with the workspace. */
    metadata?: object;
    /** Organization to which this workspace belongs. */
    organizationId?: string;
    /** Timestamp when the workspace was created. */
    createdAt?: string;
    /** Timestamp when the workspace was last updated. */
    updatedAt?: string;
    /** Timestamp when the workspace was soft-deleted. Null while the workspace is active. */
    deletedAt?: string;
  }[];
};
export type GetWorkspacesApiArg = {
  /** Organization ID used to scope the workspace listing. */
  orgId?: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
  /** JSON-encoded filter string used for assignment and soft-delete filters. */
  filter?: string;
};
export type CreateWorkspaceApiResponse = /** status 201 Created workspace */ {
  id: string;
  /** Name of the workspace. */
  name: string;
  /** Description of the workspace. */
  description?: string;
  /** Organization to which this workspace belongs. */
  organizationId: string;
  /** User ID of the workspace owner. */
  owner?: string;
  /** Metadata associated with the workspace. */
  metadata?: object;
  /** Timestamp when the workspace was created. */
  createdAt: string;
  /** Timestamp when the workspace was last updated. */
  updatedAt: string;
  /** Timestamp when the workspace was soft-deleted. Null while the workspace is active. */
  deletedAt?: string;
};
export type CreateWorkspaceApiArg = {
  /** Body for creating a workspace */
  body: {
    /** Name of the workspace. */
    name: string;
    /** Description of the workspace. */
    description?: string;
    /** Organization ID. */
    organizationId: string;
    /** Metadata associated with the workspace. */
    metadata?: object;
  };
};
export type GetWorkspaceByIdApiResponse = /** status 200 Workspace */ {
  id: string;
  /** Name of the workspace. */
  name: string;
  /** Description of the workspace. */
  description?: string;
  /** Organization to which this workspace belongs. */
  organizationId: string;
  /** User ID of the workspace owner. */
  owner?: string;
  /** Metadata associated with the workspace. */
  metadata?: object;
  /** Timestamp when the workspace was created. */
  createdAt: string;
  /** Timestamp when the workspace was last updated. */
  updatedAt: string;
  /** Timestamp when the workspace was soft-deleted. Null while the workspace is active. */
  deletedAt?: string;
};
export type GetWorkspaceByIdApiArg = {
  /** Workspace ID */
  workspaceId: string;
};
export type UpdateWorkspaceApiResponse = /** status 200 Workspace */ {
  id: string;
  /** Name of the workspace. */
  name: string;
  /** Description of the workspace. */
  description?: string;
  /** Organization to which this workspace belongs. */
  organizationId: string;
  /** User ID of the workspace owner. */
  owner?: string;
  /** Metadata associated with the workspace. */
  metadata?: object;
  /** Timestamp when the workspace was created. */
  createdAt: string;
  /** Timestamp when the workspace was last updated. */
  updatedAt: string;
  /** Timestamp when the workspace was soft-deleted. Null while the workspace is active. */
  deletedAt?: string;
};
export type UpdateWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Body for updating a workspace */
  body: {
    /** Name of the workspace. */
    name?: string;
    /** Description of the workspace. */
    description?: string;
    /** Organization ID. */
    organizationId: string;
    /** Metadata associated with the workspace. */
    metadata?: object;
  };
};
export type DeleteWorkspaceApiResponse = unknown;
export type DeleteWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
};
export type GetTeamsOfWorkspaceApiResponse = /** status 200 Teams */ {
  page?: number;
  page_size?: number;
  total_count?: number;
  /** The teams of the teampage. */
  teams?: {
    /** Team ID */
    id: string;
    /** Team name */
    name: string;
    /** Team description */
    description?: string;
    /** User ID of the owner of the team */
    owner?: string;
    /** Additional metadata for the team */
    metadata?: object;
    created_at?: string;
    updated_at?: string;
    /** SQL null Timestamp to handle null values of time. */
    deleted_at?: string;
  }[];
};
export type GetTeamsOfWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
  /** JSON-encoded filter string used for assignment and soft-delete filters. */
  filter?: string;
};
export type AssignTeamToWorkspaceApiResponse = /** status 200 Workspace team mappings */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Workspace-team mapping entries. */
  workspacesTeamsMapping?: {
    id: string;
    /** Workspace ID for this mapping. */
    workspaceId: string;
    /** Team ID for this mapping. */
    teamId: string;
    /** Timestamp when the mapping was created. */
    createdAt?: string;
    /** Timestamp when the mapping was last updated. */
    updatedAt?: string;
    /** Timestamp when the mapping was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type AssignTeamToWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Team ID */
  teamId: string;
};
export type UnassignTeamFromWorkspaceApiResponse = unknown;
export type UnassignTeamFromWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Team ID */
  teamId: string;
};
export type GetEnvironmentsOfWorkspaceApiResponse = /** status 200 Environments */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Environments associated with this resource. */
  environments?: {
    /** ID */
    id: string;
    /** Specifies the version of the schema to which the environment conforms. */
    schemaVersion: string;
    /** Environment name */
    name: string;
    /** Environment description */
    description: string;
    /** Environment organization ID */
    organizationId: string;
    /** Environment owner */
    owner?: string;
    /** Timestamp when the environment was created. */
    createdAt?: string;
    /** Additional metadata associated with the environment. */
    metadata?: object;
    /** Timestamp when the environment was last updated. */
    updatedAt?: string;
    /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
    deletedAt?: string | null;
  }[];
};
export type GetEnvironmentsOfWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
  /** JSON-encoded filter string used for assignment and soft-delete filters. */
  filter?: string;
};
export type AssignEnvironmentToWorkspaceApiResponse = /** status 200 Workspace environment mappings */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Workspace-environment mapping entries. */
  workspacesEnvironmentsMapping?: {
    id: string;
    /** Workspace ID for this mapping. */
    workspaceId: string;
    /** Environment ID for this mapping. */
    environmentId: string;
    /** Timestamp when the mapping was created. */
    createdAt?: string;
    /** Timestamp when the mapping was last updated. */
    updatedAt?: string;
    /** Timestamp when the mapping was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type AssignEnvironmentToWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Environment ID */
  environmentId: string;
};
export type UnassignEnvironmentFromWorkspaceApiResponse = unknown;
export type UnassignEnvironmentFromWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Environment ID */
  environmentId: string;
};
export type GetDesignsOfWorkspaceApiResponse = /** status 200 Designs */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Designs in this page. */
  designs?: {
    catalogData?: {
      /** Tracks the specific content version that has been made available in the Catalog. */
      publishedVersion?: string;
      /** Published content is classifed by its support level. Content classes help you understand the origin and expected support level for each piece of content. It is important to note that the level of support may vary within each class, and you should exercise discretion when using community-contributed content. Content produced and fully supported by Meshery maintainers. This represents the highest level of support and is considered the most reliable. Content produced by partners and verified by Meshery maintainers. While not directly maintained by Meshery, it has undergone a verification process to ensure quality and compatibility. Content produced and supported by the respective project or organization responsible for the specific technology. This class offers a level of support from the project maintainers themselves. Content produced and shared by Meshery users. This includes a wide range of content, such as performance profiles, test results, filters, patterns, and applications. Community content may have varying levels of support and reliability. */
      class?: "official" | "verified" | "reference architecture";
      /** One or more models associated with this catalog item. For designs, a list of one or more models implicated by components within the design. For models, this is self-referential. */
      compatibility: "kubernetes"[];
      /** Specific stipulations to consider and known behaviors to be aware of when using this design. */
      pattern_caveats: string;
      /** Purpose of the design along with its intended and unintended uses. */
      pattern_info: string;
      /** Categorization of the type of design or operational flow depicted in this design. */
      type:
        | "Deployment"
        | "Observability"
        | "Resiliency"
        | "Scaling"
        | "Security"
        | "Traffic-management"
        | "Troubleshooting"
        | "Workloads";
      /** Contains reference to the dark and light mode snapshots of the design. */
      snapshotURL?: string[];
    };
    created_at?: string;
    user_id?: string;
    location?: {
      [key: string]: string;
    };
    name?: string;
    /** Designs are your primary tool for collaborative authorship of your infrastructure, workflow, and processes. */
    patternFile?: {
      /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
      id: string;
      /** Name of the design; a descriptive, but concise title for the design document. */
      name: string;
      /** Specifies the version of the schema to which the design conforms. */
      schemaVersion: string;
      /** Revision of the design as expressed by an auto-incremented, SemVer-compliant version number. May be manually set by a user or third-party system, but will always be required to be of version number higher than the previously defined version number. */
      version: string;
      metadata?: {
        /** Map of resolved aliases present in the design */
        resolvedAliases?: {
          [key: string]: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            relationship_id: string;
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            alias_component_id: string;
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            immediate_parent_id: string;
            immediate_ref_field_path: string[];
          } & {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            resolved_parent_id: string;
            resolved_ref_field_path: string[];
          };
        };
        [key: string]: any;
      };
      /** A list of one or more component declarations. */
      components: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** Specifies the version of the schema to which the component definition conforms. */
        schemaVersion: string;
        /** Version of the component definition. */
        version: string;
        /** Name of the component in human-readible format. */
        displayName: string;
        /** A written representation of the purpose and characteristics of the component. */
        description: string;
        /** Format specifies the format used in the `component.schema` field. JSON is the default. */
        format: "JSON" | "CUE";
        /** 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 */
        model: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** Specifies the version of the schema used for the definition. */
          schemaVersion: string;
          /** Version of the model definition. */
          version: string;
          /** The unique name for the model within the scope of a registrant. */
          name: string;
          /** Human-readable name for the model. */
          displayName: string;
          /** Description of the model. */
          description: string;
          /** Status of model, including:
                    - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
                    - maintenance: model is unavailable for a period of time.
                    - enabled: model is available for use for all users of this Meshery Server.
                    - ignored: model is unavailable for use for all users of this Meshery Server. */
          status: "ignored" | "enabled" | "duplicate";
          /** Meshery Connections are managed and unmanaged resources that either through discovery or manual entry are tracked by Meshery. Learn more at https://docs.meshery.io/concepts/logical/connections */
          registrant: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id: string;
            /** Connection Name */
            name: string;
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            credentialId?: string;
            /** Connection Type (platform, telemetry, collaboration) */
            type: string;
            /** Connection Subtype (cloud, identity, metrics, chat, git, orchestration) */
            subType: string;
            /** Connection Kind (meshery, kubernetes, prometheus, grafana, gke, aws, azure, slack, github) */
            kind: string;
            /** Additional connection metadata */
            metadata?: object;
            /** Connection Status */
            status:
              | "discovered"
              | "registered"
              | "connected"
              | "ignored"
              | "maintenance"
              | "disconnected"
              | "deleted"
              | "not found";
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            user_id?: string;
            created_at?: string;
            updated_at?: string;
            /** SQL null Timestamp to handle null values of time. */
            deleted_at?: string;
            /** Associated environments for this connection */
            environments?: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id: string;
              /** Specifies the version of the schema to which the environment conforms. */
              schemaVersion: string;
              /** Environment name */
              name: string;
              /** Environment description */
              description: string;
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              organization_id: string;
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              owner?: string;
              /** Timestamp when the resource was created. */
              created_at?: string;
              /** Additional metadata associated with the environment. */
              metadata?: object;
              /** Timestamp when the resource was updated. */
              updated_at?: string;
              /** Timestamp when the environment was soft deleted. Null while the environment remains active. */
              deleted_at?: string | null;
            }[];
            /** Specifies the version of the schema used for the definition. */
            schemaVersion: string;
          };
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          registrantId: string;
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          categoryId: string;
          /** Category of the model. */
          category: {
            /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
            id: string;
            /** The category of the model that determines the main grouping. */
            name:
              | "Analytics"
              | "App Definition and Development"
              | "Cloud Native Network"
              | "Cloud Native Storage"
              | "Database"
              | "Machine Learning"
              | "Observability and Analysis"
              | "Orchestration & Management"
              | "Platform"
              | "Provisioning"
              | "Runtime"
              | "Security & Compliance"
              | "Serverless"
              | "Tools"
              | "Uncategorized";
            /** Additional metadata associated with the category. */
            metadata: object;
          };
          /** Sub category of the model determines the secondary grouping. */
          subCategory:
            | "API Gateway"
            | "API Integration"
            | "Application Definition & Image Build"
            | "Automation & Configuration"
            | "Certified Kubernetes - Distribution"
            | "Chaos Engineering"
            | "Cloud Native Storage"
            | "Cloud Provider"
            | "CNI"
            | "Compute"
            | "Container Registry"
            | "Container Runtime"
            | "Container Security"
            | "Container"
            | "Content Delivery Network"
            | "Continuous Integration & Delivery"
            | "Coordination & Service Discovery"
            | "Database"
            | "Flowchart"
            | "Framework"
            | "Installable Platform"
            | "Key Management"
            | "Key Management Service"
            | "Kubernetes"
            | "Logging"
            | "Machine Learning"
            | "Management Governance"
            | "Metrics"
            | "Monitoring"
            | "Networking Content Delivery"
            | "Operating System"
            | "Query"
            | "Remote Procedure Call"
            | "Scheduling & Orchestration"
            | "Secrets Management"
            | "Security Identity & Compliance"
            | "Service Mesh"
            | "Service Proxy"
            | "Source Version Control"
            | "Storage"
            | "Specifications"
            | "Streaming & Messaging"
            | "Tools"
            | "Tracing"
            | "Uncategorized"
            | "Video Conferencing";
          /** Metadata containing additional information associated with the model. */
          metadata?: {
            /** Capabilities associated with the model */
            capabilities?: {
              /** Specifies the version of the schema to which the capability definition conforms. */
              schemaVersion: string;
              /** Version of the capability definition. */
              version: string;
              /** Name of the capability in human-readible format. */
              displayName: string;
              /** A written representation of the purpose and characteristics of the capability. */
              description: string;
              /** Top-level categorization of the capability */
              kind: "action" | "mutate" | "view" | "interaction";
              /** Classification of capabilities. Used to group capabilities similar in nature. */
              type: string;
              /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
              subType: string;
              /** Key that backs the capability. */
              key: string;
              /** State of the entity in which the capability is applicable. */
              entityState: ("declaration" | "instance")[];
              /** Status of the capability */
              status: "enabled" | "disabled";
              /** Metadata contains additional information associated with the capability. Extension point. */
              metadata?: {
                [key: string]: any;
              };
            }[];
            /** Indicates whether the model and its entities should be treated as deployable entities or as logical representations. */
            isAnnotation?: boolean;
            /** Primary color associated with the model. */
            primaryColor?: string;
            /** Secondary color associated with the model. */
            secondaryColor?: string;
            /** SVG representation of the model in white color. */
            svgWhite: string;
            /** SVG representation of the model in colored format. */
            svgColor: string;
            /** SVG representation of the complete model. */
            svgComplete?: string;
            /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
            shape?:
              | "ellipse"
              | "triangle"
              | "round-triangle"
              | "rectangle"
              | "round-rectangle"
              | "bottom-round-rectangle"
              | "cut-rectangle"
              | "barrel"
              | "rhomboid"
              | "diamond"
              | "round-diamond"
              | "pentagon"
              | "round-pentagon"
              | "hexagon"
              | "round-hexagon"
              | "concave-hexagon"
              | "heptagon"
              | "round-heptagon"
              | "octagon"
              | "round-octagon"
              | "star"
              | "tag"
              | "round-tag"
              | "vee"
              | "polygon";
            [key: string]: any;
          };
          /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
          model: {
            /** Version of the model as defined by the registrant. */
            version: string;
          };
          /** The relationships of the model. */
          relationships: any;
          /** The components of the model. */
          components: any;
          /** Number of components associated with the model. */
          componentsCount: number;
          /** Number of relationships associated with the model. */
          relationshipsCount: number;
          /** Timestamp when the resource was created. */
          created_at?: string;
          /** Timestamp when the resource was updated. */
          updated_at?: string;
        };
        /** 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 */
        modelReference: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The unique name for the model within the scope of a registrant. */
          name: string;
          /** Version of the model definition. */
          version: string;
          /** Human-readable name for the model. */
          displayName: string;
          /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
          model: {
            /** Version of the model as defined by the registrant. */
            version: string;
          };
          registrant: {
            /** Kind of the registrant. */
            kind: string;
          };
        };
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        modelId?: string;
        /** Visualization styles for a component */
        styles?: {
          /** Primary color of the component used for UI representation. */
          primaryColor: string;
          /** Secondary color of the entity used for UI representation. */
          secondaryColor?: string;
          /** White SVG of the entity used for UI representation on dark background. */
          svgWhite: string;
          /** Colored SVG of the entity used for UI representation on light background. */
          svgColor: string;
          /** Complete SVG of the entity used for UI representation, often inclusive of background. */
          svgComplete: string;
          /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
          color?: string;
          /** The opacity of the label text, including its outline. */
          "text-opacity"?: number;
          /** A comma-separated list of font names to use on the label text. */
          "font-family"?: string;
          /** The size of the label text. */
          "font-size"?: string;
          /** A CSS font style to be applied to the label text. */
          "font-style"?: string;
          /** A CSS font weight to be applied to the label text. */
          "font-weight"?: string;
          /** A transformation to apply to the label text */
          "text-transform"?: "none" | "uppercase" | "lowercase";
          /** 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. */
          opacity?: number;
          /** 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. */
          "z-index"?: number;
          /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
          label?: string;
          /** The animation to apply to the element. example ripple,bounce,etc */
          animation?: object;
          [key: string]: any;
        } & {
          /** The shape of the node's body. Note that each shape fits within the specified width and height, and so you may have to adjust width and height if you desire an equilateral shape (i.e. width !== height for several equilateral shapes) */
          shape:
            | "ellipse"
            | "triangle"
            | "round-triangle"
            | "rectangle"
            | "round-rectangle"
            | "bottom-round-rectangle"
            | "cut-rectangle"
            | "barrel"
            | "rhomboid"
            | "diamond"
            | "round-diamond"
            | "pentagon"
            | "round-pentagon"
            | "hexagon"
            | "round-hexagon"
            | "concave-hexagon"
            | "heptagon"
            | "round-heptagon"
            | "octagon"
            | "round-octagon"
            | "star"
            | "tag"
            | "round-tag"
            | "vee"
            | "polygon";
          /** The position of the node. If the position is set, the node is drawn at that position in the given dimensions. If the position is not set, the node is drawn at a random position. */
          position?: {
            /** The x-coordinate of the node. */
            x: number;
            /** The y-coordinate of the node. */
            y: number;
          };
          /** The text to display for an element's body. Can give a path, e.g. data(id) will label with the elements id */
          "body-text"?: string;
          /** How to wrap the text in the node. Can be 'none', 'wrap', or 'ellipsis'. */
          "body-text-wrap"?: string;
          /** The maximum width for wrapping text in the node. */
          "body-text-max-width"?: string;
          /** The opacity of the node's body text, including its outline. */
          "body-text-opacity"?: number;
          /** The colour of the node's body text background. Colours may be specified by name (e.g. red), hex (e.g. */
          "body-text-background-color"?: string;
          /** The size of the node's body text. */
          "body-text-font-size"?: number;
          /** The colour of the node's body text. Colours may be specified by name (e.g. red), hex (e.g. */
          "body-text-color"?: string;
          /** A CSS font weight to be applied to the node's body text. */
          "body-text-font-weight"?: string;
          /** A CSS horizontal alignment to be applied to the node's body text. */
          "body-text-horizontal-align"?: string;
          /** A CSS text decoration to be applied to the node's body text. */
          "body-text-decoration"?: string;
          /** A CSS vertical alignment to be applied to the node's body text. */
          "body-text-vertical-align"?: string;
          /** The width of the node's body or the width of an edge's line. */
          width?: number;
          /** The height of the node's body */
          height?: number;
          /** The URL that points to the image to show in the node. */
          "background-image"?: string;
          /** The colour of the node's body. Colours may be specified by name (e.g. red), hex (e.g. */
          "background-color"?: string;
          /** Blackens the node's body for values from 0 to 1; whitens the node's body for values from 0 to -1. */
          "background-blacken"?: number;
          /** The opacity level of the node's background colour */
          "background-opacity"?: number;
          /** The x position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
          "background-position-x"?: string;
          /** The y position of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
          "background-position-y"?: string;
          /** The x offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
          "background-offset-x"?: string;
          /** The y offset of the background image, measured in percent (e.g. 50%) or pixels (e.g. 10px) */
          "background-offset-y"?: string;
          /** How the background image is fit to the node. Can be 'none', 'contain', or 'cover'. */
          "background-fit"?: string;
          /** How the background image is clipped to the node. Can be 'none', 'node', or 'node-border'. */
          "background-clip"?: string;
          /** How the background image's width is determined. Can be 'none', 'inner', or 'outer'. */
          "background-width-relative-to"?: string;
          /** How the background image's height is determined. Can be 'none', 'inner', or 'outer'. */
          "background-height-relative-to"?: string;
          /** The size of the node's border. */
          "border-width"?: number;
          /** The style of the node's border */
          "border-style"?: "solid" | "dotted" | "dashed" | "double";
          /** The colour of the node's border. Colours may be specified by name (e.g. red), hex (e.g. */
          "border-color"?: string;
          /** The opacity of the node's border */
          "border-opacity"?: number;
          /** The amount of padding around all sides of the node. */
          padding?: number;
          /** The horizontal alignment of a node's label */
          "text-halign"?: "left" | "center" | "right";
          /** The vertical alignment of a node's label */
          "text-valign"?: "top" | "center" | "bottom";
          /** Whether to use the ghost effect, a semitransparent duplicate of the element drawn at an offset. */
          ghost?: "yes" | "no";
          /** The colour of the indicator shown when the background is grabbed by the user. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
          "active-bg-color"?: string;
          /** The opacity of the active background indicator. Selector needs to be *core*. */
          "active-bg-opacity"?: string;
          /** The opacity of the active background indicator. Selector needs to be *core*. */
          "active-bg-size"?: string;
          /** The background colour of the selection box used for drag selection. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
          "selection-box-color"?: string;
          /** The size of the border on the selection box. Selector needs to be *core* */
          "selection-box-border-width"?: number;
          /** The opacity of the selection box. Selector needs to be *core* */
          "selection-box-opacity"?: number;
          /** The colour of the area outside the viewport texture when initOptions.textureOnViewport === true. Selector needs to be *core*. Colours may be specified by name (e.g. red), hex (e.g. */
          "outside-texture-bg-color"?: string;
          /** The opacity of the area outside the viewport texture. Selector needs to be *core* */
          "outside-texture-bg-opacity"?: number;
          /** An array (or a space-separated string) of numbers ranging on [-1, 1], representing alternating x and y values (i.e. x1 y1 x2 y2, x3 y3 ...). This represents the points in the polygon for the node's shape. The bounding box of the node is given by (-1, -1), (1, -1), (1, 1), (-1, 1). The node's position is the origin (0, 0 ) */
          "shape-polygon-points"?: string;
          /** The colour of the background of the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
          "menu-background-color"?: string;
          /** The opacity of the background of the component menu. */
          "menu-background-opacity"?: number;
          /** The colour of the text or icons in the component menu. Colours may be specified by name (e.g. red), hex (e.g. */
          "menu-forground-color"?: string;
        };
        /** Meshery manages components 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. ComponentDefinitions may define a broad array of capabilities, which are in-turn dynamically interpretted by Meshery for full lifecycle management. */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Status of component, including:
                - duplicate: this component is a duplicate of another. The component that is to be the canonical reference and that is duplicated by other components should not be assigned the 'duplicate' status.
                - maintenance: model is unavailable for a period of time.
                - enabled: model is available for use for all users of this Meshery Server.
                - ignored: model is unavailable for use for all users of this Meshery Server. */
        status?: "ignored" | "enabled" | "duplicate" | "resolved" | "open";
        /** Metadata contains additional information associated with the component. */
        metadata: {
          /** Genealogy represents the various representational states of the component. */
          genealogy: string;
          /** Identifies whether the component is semantically meaningful or not; identifies whether the component should be treated as deployable entity or is for purposes of logical representation. */
          isAnnotation: boolean;
          /** Identifies whether the component is scoped to namespace or clsuter wide. */
          isNamespaced: boolean;
          /** 'published' controls whether the component should be registered in Meshery Registry. When the same 'published' property in Models, is set to 'false', the Model property takes precedence with all Entities in the Model not being registered. */
          published: boolean;
          /** InstanceDetails contains information about the instance of the component. */
          instanceDetails: object;
          /** Defines the UI schema for rendering the component's configuration. For more details, visit: https://rjsf-team.github.io/react-jsonschema-form/docs/api-reference/uiSchema/ . */
          configurationUISchema: string;
          [key: string]: any;
        };
        /** The configuration of the component. The configuration is based on the schema defined within the component definition(component.schema). */
        configuration: object;
        /** data related to the third party capability that Component Defintion wraps , this is herematicaly sealed an */
        component: {
          /** Version of the component produced by the registrant. Example: APIVersion of a Kubernetes Pod. */
          version: string;
          /** The unique identifier (name) assigned by the registrant to this component. Example: A Kubernetes Pod is of kind 'Pod'. */
          kind: string;
          /** JSON schema of the object as defined by the registrant. */
          schema: string;
        };
        /** Timestamp when the resource was created. */
        created_at?: string;
        /** Timestamp when the resource was updated. */
        updated_at?: string;
      }[];
      /** Design-level preferences */
      preferences?: {
        /** Map of available layers, where keys are layer names. */
        layers: object;
      };
      /** List of relationships between components */
      relationships: {
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        id: string;
        /** Specifies the version of the schema used for the relationship definition. */
        schemaVersion: string;
        /** Specifies the version of the relationship definition. */
        version: string;
        /** Kind of the Relationship. Learn more about relationships - https://docs.meshery.io/concepts/logical/relationships. */
        kind: "hierarchical" | "edge" | "sibling";
        /** Classification of relationships. Used to group relationships similar in nature. */
        type: string;
        /** Most granular unit of relationship classification. The combination of Kind, Type and SubType together uniquely identify a Relationship. */
        subType: string;
        /** Status of the relationship. */
        status?: "enabled" | "ignored" | "deleted" | "approved" | "pending";
        /** Capabilities associated with the relationship. */
        capabilities?: {
          /** Specifies the version of the schema to which the capability definition conforms. */
          schemaVersion: string;
          /** Version of the capability definition. */
          version: string;
          /** Name of the capability in human-readible format. */
          displayName: string;
          /** A written representation of the purpose and characteristics of the capability. */
          description: string;
          /** Top-level categorization of the capability */
          kind: "action" | "mutate" | "view" | "interaction";
          /** Classification of capabilities. Used to group capabilities similar in nature. */
          type: string;
          /** Most granular unit of capability classification. The combination of Kind, Type and SubType together uniquely identify a Capability. */
          subType: string;
          /** Key that backs the capability. */
          key: string;
          /** State of the entity in which the capability is applicable. */
          entityState: ("declaration" | "instance")[];
          /** Status of the capability */
          status: "enabled" | "disabled";
          /** Metadata contains additional information associated with the capability. Extension point. */
          metadata?: {
            [key: string]: any;
          };
        }[];
        /** Metadata contains additional information associated with the Relationship. */
        metadata?: {
          /** Characterization of the meaning of the relationship and its relevance to both Meshery and entities under management. */
          description?: string;
          /** Visualization styles for a relationship */
          styles?: {
            /** Primary color of the component used for UI representation. */
            primaryColor: string;
            /** Secondary color of the entity used for UI representation. */
            secondaryColor?: string;
            /** White SVG of the entity used for UI representation on dark background. */
            svgWhite: string;
            /** Colored SVG of the entity used for UI representation on light background. */
            svgColor: string;
            /** Complete SVG of the entity used for UI representation, often inclusive of background. */
            svgComplete?: string;
            /** The color of the element's label. Colours may be specified by name (e.g. red), hex (e.g. */
            color?: string;
            /** The opacity of the label text, including its outline. */
            "text-opacity"?: number;
            /** A comma-separated list of font names to use on the label text. */
            "font-family"?: string;
            /** The size of the label text. */
            "font-size"?: string;
            /** A CSS font style to be applied to the label text. */
            "font-style"?: string;
            /** A CSS font weight to be applied to the label text. */
            "font-weight"?: string;
            /** A transformation to apply to the label text */
            "text-transform"?: "none" | "uppercase" | "lowercase";
            /** 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 */
            opacity?: number;
            /** 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. */
            "z-index"?: number;
            /** The text to display for an element's label. Can give a path, e.g. data(id) will label with the elements id */
            label?: string;
            /** The animation to use for the edge. Can be like 'marching-ants' , 'blink' , 'moving-gradient',etc . */
            "edge-animation"?: string;
            /** 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. */
            "curve-style"?: "haystack" | "straight" | "bezier" | "unbundled-bezier" | "segments" | "taxi";
            /** The colour of the edge's line. Colours may be specified by name (e.g. red), hex (e.g. */
            "line-color"?: string;
            /** The style of the edge's line. */
            "line-style"?: "solid" | "dotted" | "dashed";
            /** 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. */
            "line-cap"?: "butt" | "round" | "square";
            /** 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. */
            "line-opacity"?: number;
            /** The colour of the edge's source arrow. Colours may be specified by name (e.g. red), hex (e.g. */
            "target-arrow-color"?: string;
            /** The shape of the edge's source arrow */
            "target-arrow-shape"?:
              | "triangle"
              | "triangle-tee"
              | "circle-triangle"
              | "triangle-cross"
              | "triangle-backcurve"
              | "vee"
              | "tee"
              | "square"
              | "circle"
              | "diamond"
              | "chevron"
              | "none";
            /** The fill state of the edge's source arrow */
            "target-arrow-fill"?: "filled" | "hollow";
            /** The colour of the edge's source arrow. Colours may be specified by name (e.g. red), hex (e.g. */
            "mid-target-arrow-color"?: string;
            /** The shape of the edge's source arrow */
            "mid-target-arrow-shape"?:
              | "triangle"
              | "triangle-tee"
              | "circle-triangle"
              | "triangle-cross"
              | "triangle-backcurve"
              | "vee"
              | "tee"
              | "square"
              | "circle"
              | "diamond"
              | "chevron"
              | "none";
            /** The fill state of the edge's source arrow */
            "mid-target-arrow-fill"?: "filled" | "hollow";
            /** Scaling for the arrow size. */
            "arrow-scale"?: number;
            /** The text to display for an edge's source label. Can give a path, e.g. data(id) will label with the elements id */
            "source-label"?: string;
            /** The text to display for an edge's target label. Can give a path, e.g. data(id) will label with the elements id */
            "target-label"?: string;
          };
          /** Indicates whether the relationship should be treated as a logical representation only */
          isAnnotation?: boolean;
          [key: string]: any;
        };
        /** Model 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 */
        model: {
          /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
          id: string;
          /** The unique name for the model within the scope of a registrant. */
          name: string;
          /** Version of the model definition. */
          version: string;
          /** Human-readable name for the model. */
          displayName: string;
          /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
          model: {
            /** Version of the model as defined by the registrant. */
            version: string;
          };
          registrant: {
            /** Kind of the registrant. */
            kind: string;
          };
        };
        /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
        modelId?: string;
        /** 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. */
        evaluationQuery?: string;
        /** 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. */
        selectors?: {
          /** Selectors used to define relationships which are allowed. */
          allow: {
            /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
            from: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id?: string;
              kind?: string;
              /** Match configuration for selector */
              match?: {
                refs?: string[][];
                from?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
                to?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
              };
              /** Match strategy matrix for the selector */
              match_strategy_matrix?: string[][];
              /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
              model?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id: string;
                /** The unique name for the model within the scope of a registrant. */
                name: string;
                /** Version of the model definition. */
                version: string;
                /** Human-readable name for the model. */
                displayName: string;
                /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
                model: {
                  /** Version of the model as defined by the registrant. */
                  version: string;
                };
                registrant: {
                  /** Kind of the registrant. */
                  kind: string;
                };
              };
              /** Patch configuration for the selector */
              patch?: {
                /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                                
                                add: Inserts a value into an array or adds a member to an object.
                                replace: Replaces a value.
                                merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                                strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                                remove: Removes a value.
                                copy: Copies a value from one location to another.
                                move: Moves a value from one location to another.
                                test: Tests that a value at the target location is equal to a specified value.
                                 */
                patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              };
            }[];
            /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
            to: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id?: string;
              kind?: string;
              /** Match configuration for selector */
              match?: {
                refs?: string[][];
                from?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
                to?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
              };
              /** Match strategy matrix for the selector */
              match_strategy_matrix?: string[][];
              /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
              model?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id: string;
                /** The unique name for the model within the scope of a registrant. */
                name: string;
                /** Version of the model definition. */
                version: string;
                /** Human-readable name for the model. */
                displayName: string;
                /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
                model: {
                  /** Version of the model as defined by the registrant. */
                  version: string;
                };
                registrant: {
                  /** Kind of the registrant. */
                  kind: string;
                };
              };
              /** Patch configuration for the selector */
              patch?: {
                /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                                
                                add: Inserts a value into an array or adds a member to an object.
                                replace: Replaces a value.
                                merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                                strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                                remove: Removes a value.
                                copy: Copies a value from one location to another.
                                move: Moves a value from one location to another.
                                test: Tests that a value at the target location is equal to a specified value.
                                 */
                patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              };
            }[];
          };
          /** Optional selectors used to define relationships which should not be created / is restricted. */
          deny?: {
            /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
            from: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id?: string;
              kind?: string;
              /** Match configuration for selector */
              match?: {
                refs?: string[][];
                from?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
                to?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
              };
              /** Match strategy matrix for the selector */
              match_strategy_matrix?: string[][];
              /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
              model?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id: string;
                /** The unique name for the model within the scope of a registrant. */
                name: string;
                /** Version of the model definition. */
                version: string;
                /** Human-readable name for the model. */
                displayName: string;
                /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
                model: {
                  /** Version of the model as defined by the registrant. */
                  version: string;
                };
                registrant: {
                  /** Kind of the registrant. */
                  kind: string;
                };
              };
              /** Patch configuration for the selector */
              patch?: {
                /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                                
                                add: Inserts a value into an array or adds a member to an object.
                                replace: Replaces a value.
                                merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                                strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                                remove: Removes a value.
                                copy: Copies a value from one location to another.
                                move: Moves a value from one location to another.
                                test: Tests that a value at the target location is equal to a specified value.
                                 */
                patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              };
            }[];
            /** Describes the component(s) which are involved in the relationship along with a set of actions to perform upon selection match. */
            to: {
              /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
              id?: string;
              kind?: string;
              /** Match configuration for selector */
              match?: {
                refs?: string[][];
                from?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
                to?: {
                  /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                  id?: string;
                  kind: string;
                  /** JSON ref to value from where patch should be applied. */
                  mutatorRef?: string[][];
                  mutatedRef?: string[][];
                }[];
              };
              /** Match strategy matrix for the selector */
              match_strategy_matrix?: string[][];
              /** Name of the model implicated by this selector. Learn more at https://docs.meshery.io/concepts/models */
              model?: {
                /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
                id: string;
                /** The unique name for the model within the scope of a registrant. */
                name: string;
                /** Version of the model definition. */
                version: string;
                /** Human-readable name for the model. */
                displayName: string;
                /** Registrant-defined data associated with the model. Properties pertain to the software being managed (e.g. Kubernetes v1.31). */
                model: {
                  /** Version of the model as defined by the registrant. */
                  version: string;
                };
                registrant: {
                  /** Kind of the registrant. */
                  kind: string;
                };
              };
              /** Patch configuration for the selector */
              patch?: {
                /** patchStrategy allows you to make specific changes to a resource using a standard JSON Patch format (RFC 6902).
                                
                                add: Inserts a value into an array or adds a member to an object.
                                replace: Replaces a value.
                                merge: Combines the values of the target location with the values from the patch. If the target location doesn't exist, it is created.
                                strategic: specific to Kubernetes and understands the structure of Kubernetes objects.
                                remove: Removes a value.
                                copy: Copies a value from one location to another.
                                move: Moves a value from one location to another.
                                test: Tests that a value at the target location is equal to a specified value.
                                 */
                patchStrategy?: "merge" | "strategic" | "add" | "remove" | "copy" | "move" | "test";
                /** JSON ref to value from where patch should be applied. */
                mutatorRef?: string[][];
                mutatedRef?: string[][];
              };
            }[];
          };
        }[];
      }[];
    };
    updated_at?: string;
    id?: string;
    visibility?: string;
  }[];
};
export type GetDesignsOfWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
  /** JSON-encoded filter string used for assignment and soft-delete filters. */
  filter?: string;
};
export type AssignDesignToWorkspaceApiResponse = /** status 200 Workspace design mappings */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Workspace-design mapping entries. */
  workspacesDesignsMapping?: {
    id: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    workspaceId: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    designId: string;
    /** Timestamp when the mapping was created. */
    createdAt?: string;
    /** Timestamp when the mapping was last updated. */
    updatedAt?: string;
    /** Timestamp when the mapping was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type AssignDesignToWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Design ID */
  designId: string;
};
export type UnassignDesignFromWorkspaceApiResponse = unknown;
export type UnassignDesignFromWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Design ID */
  designId: string;
};
export type GetViewsOfWorkspaceApiResponse = /** status 200 Views */ {
  page?: number;
  page_size?: number;
  total_count?: number;
  /** Views in this page, enriched with workspace and organization context. */
  views?: {
    id?: string;
    /** Display name of the view. */
    name?: string;
    /** Visibility level of the view. */
    visibility?: string;
    /** Filter configuration for this view. */
    filters?: object;
    /** Metadata associated with the view. */
    metadata?: object;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    user_id?: string;
    /** Name of the workspace this view belongs to. */
    workspace_name?: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    workspace_id: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    organization_id: string;
    /** Name of the organization this view belongs to. */
    organization_name?: string;
    /** Timestamp when the resource was created. */
    created_at?: string;
    /** Timestamp when the resource was updated. */
    updated_at?: string;
    /** Timestamp when the view was soft deleted. Null while the view remains active. */
    deleted_at?: string;
  }[];
};
export type GetViewsOfWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** Get responses that match search param value */
  search?: string;
  /** Get ordered responses */
  order?: string;
  /** Get responses by page */
  page?: number;
  /** Number of responses to return per page. Canonical camelCase pagination parameter; prefer this over the deprecated all-lowercase `pagesize`. */
  pageSize?: number;
  /** Get responses by pagesize. Deprecated alias of pageSize. */
  pagesize?: number;
  /** JSON-encoded filter string used for assignment and soft-delete filters. */
  filter?: string;
};
export type AssignViewToWorkspaceApiResponse = /** status 200 Workspace view mappings */ {
  /** Zero-based page index returned in this response. */
  page?: number;
  /** Maximum number of items returned on each page. */
  pageSize?: number;
  /** Total number of items across all pages. */
  totalCount?: number;
  /** Workspace-view mapping entries. */
  workspacesViewsMapping?: {
    id: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    workspaceId: string;
    /** A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas. */
    viewId: string;
    /** Timestamp when the resource was created. */
    createdAt?: string;
    /** Timestamp when the resource was updated. */
    updatedAt?: string;
    /** Timestamp when the mapping was soft-deleted. */
    deletedAt?: string;
  }[];
};
export type AssignViewToWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** View ID */
  viewId: string;
};
export type UnassignViewFromWorkspaceApiResponse = unknown;
export type UnassignViewFromWorkspaceApiArg = {
  /** Workspace ID */
  workspaceId: string;
  /** View ID */
  viewId: string;
};
export const {
  useGetControllersDefaultConfigQuery,
  useLazyGetControllersDefaultConfigQuery,
  useUpdateControllersDefaultConfigMutation,
  useGetConnectionControllersConfigQuery,
  useLazyGetConnectionControllersConfigQuery,
  useUpdateConnectionControllersConfigMutation,
  useGetConsoleCapabilitiesQuery,
  useLazyGetConsoleCapabilitiesQuery,
  useOpenTerminalConsoleQuery,
  useLazyOpenTerminalConsoleQuery,
  useOpenLogConsoleQuery,
  useLazyOpenLogConsoleQuery,
  useEvaluateRelationshipsMutation,
  useGetRegistryModelsQuery,
  useLazyGetRegistryModelsQuery,
  useGetRegistryModelsByNameQuery,
  useLazyGetRegistryModelsByNameQuery,
  useDeleteRegistryModelMutation,
  useGetRegistryComponentsByModelQuery,
  useLazyGetRegistryComponentsByModelQuery,
  useGetRegistryComponentsByModelAndNameQuery,
  useLazyGetRegistryComponentsByModelAndNameQuery,
  useGetRegistryRelationshipsByModelQuery,
  useLazyGetRegistryRelationshipsByModelQuery,
  useGetRegistryRelationshipsByModelAndNameQuery,
  useLazyGetRegistryRelationshipsByModelAndNameQuery,
  useGetRegistryPoliciesByModelQuery,
  useLazyGetRegistryPoliciesByModelQuery,
  useGetRegistryPoliciesByModelAndNameQuery,
  useLazyGetRegistryPoliciesByModelAndNameQuery,
  useGetRegistryCategoriesQuery,
  useLazyGetRegistryCategoriesQuery,
  useGetRegistryCategoriesByNameQuery,
  useLazyGetRegistryCategoriesByNameQuery,
  useGetRegistryModelsByCategoryQuery,
  useLazyGetRegistryModelsByCategoryQuery,
  useGetRegistryModelsByCategoryAndModelQuery,
  useLazyGetRegistryModelsByCategoryAndModelQuery,
  useGetRegistryComponentsByCategoryAndModelQuery,
  useLazyGetRegistryComponentsByCategoryAndModelQuery,
  useGetRegistryComponentsByCategoryAndModelAndNameQuery,
  useLazyGetRegistryComponentsByCategoryAndModelAndNameQuery,
  useGetRegistryComponentsByCategoryQuery,
  useLazyGetRegistryComponentsByCategoryQuery,
  useGetRegistryComponentsByCategoryAndNameQuery,
  useLazyGetRegistryComponentsByCategoryAndNameQuery,
  useGetRegistryComponentsQuery,
  useLazyGetRegistryComponentsQuery,
  useRegisterRegistryComponentMutation,
  useGetRegistryComponentsByNameQuery,
  useLazyGetRegistryComponentsByNameQuery,
  useGetRegistryRelationshipsQuery,
  useLazyGetRegistryRelationshipsQuery,
  useRegisterRegistryRelationshipMutation,
  useGetRegistryRegistrantsQuery,
  useLazyGetRegistryRegistrantsQuery,
  useRegisterRegistryEntitiesMutation,
  useGenerateRegistryComponentsMutation,
  useExportRegistryModelQuery,
  useLazyExportRegistryModelQuery,
  useValidateRegistryEntitiesMutation,
  useUpdateRegistryEntityStatusMutation,
  useGetSystemDatabaseQuery,
  useLazyGetSystemDatabaseQuery,
  useResetSystemDatabaseMutation,
  useGetSystemVersionQuery,
  useLazyGetSystemVersionQuery,
  useAddKubernetesConfigMutation,
  useDiscoverKubernetesContextsMutation,
  usePingKubernetesQuery,
  useLazyPingKubernetesQuery,
  useGetSystemSyncQuery,
  useLazyGetSystemSyncQuery,
  useGetOperatorControllerStatusQuery,
  useLazyGetOperatorControllerStatusQuery,
  useGetMeshsyncControllerStatusQuery,
  useLazyGetMeshsyncControllerStatusQuery,
  useGetBrokerControllerStatusQuery,
  useLazyGetBrokerControllerStatusQuery,
  useGetControllerDiagnosticsQuery,
  useLazyGetControllerDiagnosticsQuery,
  useSubscribeControllersStatusQuery,
  useLazySubscribeControllersStatusQuery,
  useGetUserCredentialsQuery,
  useLazyGetUserCredentialsQuery,
  useSaveUserCredentialMutation,
  useUpdateUserCredentialMutation,
  useDeleteUserCredentialMutation,
  useGetCredentialByIdQuery,
  useLazyGetCredentialByIdQuery,
  useGetUserKeysQuery,
  useLazyGetUserKeysQuery,
  useGetOrgsQuery,
  useLazyGetOrgsQuery,
  useCreateOrgMutation,
  useGetOrgByDomainQuery,
  useLazyGetOrgByDomainQuery,
  useGetOrgQuery,
  useLazyGetOrgQuery,
  useDeleteOrgMutation,
  useUpdateOrgMutation,
  useGetOrgPreferencesQuery,
  useLazyGetOrgPreferencesQuery,
  useAddTeamToOrgMutation,
  useRemoveTeamFromOrgMutation,
  useAddUserToOrgMutation,
  useDeleteUserFromOrgMutation,
  useGetUsersForOrgQuery,
  useLazyGetUsersForOrgQuery,
  useGetUserProfileByIdQuery,
  useLazyGetUserProfileByIdQuery,
  useGetUserQuery,
  useLazyGetUserQuery,
  useGetUserEmailAddressesQuery,
  useLazyGetUserEmailAddressesQuery,
  useGetConnectionsQuery,
  useLazyGetConnectionsQuery,
  useRegisterConnectionMutation,
  useProcessConnectionRegistrationMutation,
  useCancelConnectionRegisterMutation,
  useGetConnectionByIdQuery,
  useLazyGetConnectionByIdQuery,
  useUpdateConnectionMutation,
  useDeleteConnectionMutation,
  usePerformConnectionActionMutation,
  useDeleteMesheryConnectionMutation,
  useGetKubernetesContextQuery,
  useLazyGetKubernetesContextQuery,
  useAddConnectionToEnvironmentMutation,
  useRemoveConnectionFromEnvironmentMutation,
  useListConnectionDefinitionsQuery,
  useLazyListConnectionDefinitionsQuery,
  useRegisterConnectionDefinitionMutation,
  useGetConnectionDefinitionQuery,
  useLazyGetConnectionDefinitionQuery,
  useUpdateConnectionDefinitionMutation,
  useDeleteConnectionDefinitionMutation,
  useImportDesignMutation,
  useCreateEnvironmentMutation,
  useGetEnvironmentsQuery,
  useLazyGetEnvironmentsQuery,
  useGetEnvironmentByIdQuery,
  useLazyGetEnvironmentByIdQuery,
  useUpdateEnvironmentMutation,
  useDeleteEnvironmentMutation,
  useGetEnvironmentConnectionsQuery,
  useLazyGetEnvironmentConnectionsQuery,
  useDeleteEventMutation,
  useBulkDeleteEventsMutation,
  useBulkUpdateEventStatusMutation,
  useUpdateEventStatusMutation,
  useCreateEventMutation,
  useGetPerformanceProfilesQuery,
  useLazyGetPerformanceProfilesQuery,
  useUpsertPerformanceProfileMutation,
  useGetPerformanceProfileQuery,
  useLazyGetPerformanceProfileQuery,
  useUpdatePerformanceProfileMutation,
  useDeletePerformanceProfileMutation,
  useGetPerformanceProfileResultsQuery,
  useLazyGetPerformanceProfileResultsQuery,
  useGetPerformanceResultsQuery,
  useLazyGetPerformanceResultsQuery,
  useGetUsersQuery,
  useLazyGetUsersQuery,
  useSearchUsersQuery,
  useLazySearchUsersQuery,
  useGetWorkspacesQuery,
  useLazyGetWorkspacesQuery,
  useCreateWorkspaceMutation,
  useGetWorkspaceByIdQuery,
  useLazyGetWorkspaceByIdQuery,
  useUpdateWorkspaceMutation,
  useDeleteWorkspaceMutation,
  useGetTeamsOfWorkspaceQuery,
  useLazyGetTeamsOfWorkspaceQuery,
  useAssignTeamToWorkspaceMutation,
  useUnassignTeamFromWorkspaceMutation,
  useGetEnvironmentsOfWorkspaceQuery,
  useLazyGetEnvironmentsOfWorkspaceQuery,
  useAssignEnvironmentToWorkspaceMutation,
  useUnassignEnvironmentFromWorkspaceMutation,
  useGetDesignsOfWorkspaceQuery,
  useLazyGetDesignsOfWorkspaceQuery,
  useAssignDesignToWorkspaceMutation,
  useUnassignDesignFromWorkspaceMutation,
  useGetViewsOfWorkspaceQuery,
  useLazyGetViewsOfWorkspaceQuery,
  useAssignViewToWorkspaceMutation,
  useUnassignViewFromWorkspaceMutation,
} = injectedRtkApi;
