@meshery/schemas 1.3.9 → 1.4.0

package/dist/constructs/v1beta3/performance_profile/PerformanceProfile.d.ts

@@ -4,127 +4,590 @@
  */
 
 export interface paths {
-    "/api/performance/profiles": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
+  "/api/performance/profiles": {
+    /** Returns the performance profiles owned by the authenticated user, with pagination, search, and ordering. */
+    get: operations["getPerformanceProfiles"];
+    /** Creates a new performance profile when the body omits id, or updates the matching existing profile when an id is provided. */
+    post: operations["upsertPerformanceProfile"];
+  };
+  "/api/performance/profiles/{performanceProfileId}": {
+    /** Returns a single performance profile owned by (or visible to) the authenticated user. */
+    get: operations["getPerformanceProfile"];
+    /** Updates the performance profile identified by the path parameter. */
+    put: operations["updatePerformanceProfile"];
+    /** Deletes the performance profile identified by the path parameter and any associated performance results. */
+    delete: operations["deletePerformanceProfile"];
+  };
+  "/api/performance/profiles/{performanceProfileId}/results": {
+    /** Returns paginated load-test results associated with the performance profile identified by the path parameter. */
+    get: operations["getPerformanceProfileResults"];
+  };
+  "/api/performance/profiles/{performanceProfileId}/results/{resultId}": {
+    /** Returns one load-test result associated with the performance profile identified by the path parameter. */
+    get: operations["getPerformanceProfileResult"];
+  };
+  "/api/performance/results": {
+    /** Returns paginated load-test results visible to the authenticated user. */
+    get: operations["getPerformanceResults"];
+  };
+}
+
+export interface components {
+  schemas: {
+    /**
+     * PerformanceProfile
+     * @description A performance profile captures the configuration for a load test run by Meshery against one or more service-mesh endpoints. Profiles are owned by a user and can optionally be associated with a recurring schedule. Learn more at https://docs.meshery.io/tasks/performance-management
+     */
+    PerformanceProfile: {
+      /**
+       * Format: uuid
+       * @description Unique identifier for the performance profile.
+       */
+      id: string;
+      /** @description Human-readable name of the performance profile. */
+      name: string;
+      /**
+       * Format: uuid
+       * @description User ID of the profile owner.
+       */
+      owner: string;
+      /**
+       * Format: uuid
+       * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
+       */
+      schedule?: string | null;
+      /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
+      loadGenerators?: string[];
+      /** @description Endpoints (URLs) targeted by the performance profile's load test. */
+      endpoints?: string[];
+      /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
+      serviceMesh?: string;
+      /** @description Number of concurrent requests issued by the load generator. */
+      concurrentRequest?: number;
+      /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
+      qps?: number;
+      /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+      duration?: string;
+      /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
+      requestHeaders?: string;
+      /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
+      requestCookies?: string;
+      /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
+      requestBody?: string;
+      /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
+      contentType?: string;
+      /** @description Free-form metadata associated with the performance profile. */
+      metadata?: { [key: string]: unknown };
+      /**
+       * Format: date-time
+       * @description 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;
+      /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
+      totalResults?: number;
+      /**
+       * Format: date-time
+       * @description Timestamp when the performance profile was created.
+       */
+      createdAt: string;
+      /**
+       * Format: date-time
+       * @description Timestamp when the performance profile was last updated.
+       */
+      updatedAt: string;
+    };
+    /** @description Payload for creating or updating a performance profile. Includes only client-settable fields; server-generated fields (id on create, createdAt, updatedAt, lastRun, totalResults) are populated by the server. */
+    PerformanceProfilePayload: {
+      /**
+       * Format: uuid
+       * @description Existing performance-profile ID for updates; omit on create.
+       */
+      id?: string;
+      /** @description Human-readable name of the performance profile. */
+      name: string;
+      /**
+       * Format: uuid
+       * @description Owner user ID. When omitted, the server infers it from the authenticated user.
+       */
+      userId?: string;
+      /**
+       * Format: uuid
+       * @description Optional schedule ID associating the profile with a recurring run.
+       */
+      schedule?: string | null;
+      /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
+      loadGenerators: string[];
+      /** @description Endpoints (URLs) targeted by the performance profile's load test. */
+      endpoints: string[];
+      /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
+      serviceMesh?: string;
+      /** @description Number of concurrent requests issued by the load generator. */
+      concurrentRequest?: number;
+      /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
+      qps?: number;
+      /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+      duration: string;
+      /** @description HTTP request headers, serialized as JSON, sent on each load-test request. */
+      requestHeaders?: string;
+      /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. */
+      requestCookies?: string;
+      /** @description HTTP request body sent on each load-test request. */
+      requestBody?: string;
+      /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). */
+      contentType?: string;
+      /** @description Free-form metadata associated with the performance profile. */
+      metadata?: { [key: string]: unknown };
+    };
+    /** @description Paginated list of performance profiles. */
+    PerformanceProfilePage: {
+      /** @description Zero-based page index returned in this response. */
+      page: number;
+      /** @description Maximum number of items returned on each page. */
+      pageSize: number;
+      /** @description Total number of performance profiles across all pages. */
+      totalCount: number;
+      /** @description Performance profiles in this page. */
+      profiles: {
         /**
-         * List performance profiles
-         * @description Returns the performance profiles owned by the authenticated user, with pagination, search, and ordering.
+         * Format: uuid
+         * @description Unique identifier for the performance profile.
          */
-        get: operations["getPerformanceProfiles"];
-        put?: never;
+        id: string;
+        /** @description Human-readable name of the performance profile. */
+        name: string;
         /**
-         * Create or update a performance profile
-         * @description Creates a new performance profile when the body omits id, or updates the matching existing profile when an id is provided.
+         * Format: uuid
+         * @description User ID of the profile owner.
          */
-        post: operations["upsertPerformanceProfile"];
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/performance/profiles/{performanceProfileId}": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
+        owner: string;
         /**
-         * Get a performance profile by ID
-         * @description Returns a single performance profile owned by (or visible to) the authenticated user.
+         * Format: uuid
+         * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
          */
-        get: operations["getPerformanceProfile"];
+        schedule?: string | null;
+        /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
+        loadGenerators?: string[];
+        /** @description Endpoints (URLs) targeted by the performance profile's load test. */
+        endpoints?: string[];
+        /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
+        serviceMesh?: string;
+        /** @description Number of concurrent requests issued by the load generator. */
+        concurrentRequest?: number;
+        /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
+        qps?: number;
+        /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+        duration?: string;
+        /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
+        requestHeaders?: string;
+        /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
+        requestCookies?: string;
+        /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
+        requestBody?: string;
+        /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
+        contentType?: string;
+        /** @description Free-form metadata associated with the performance profile. */
+        metadata?: { [key: string]: unknown };
         /**
-         * Update a performance profile
-         * @description Updates the performance profile identified by the path parameter.
+         * Format: date-time
+         * @description 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.
          */
-        put: operations["updatePerformanceProfile"];
-        post?: never;
+        lastRun?: string | null;
+        /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
+        totalResults?: number;
         /**
-         * Delete a performance profile
-         * @description Deletes the performance profile identified by the path parameter and any associated performance results.
+         * Format: date-time
+         * @description Timestamp when the performance profile was created.
          */
-        delete: operations["deletePerformanceProfile"];
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/performance/profiles/{performanceProfileId}/results": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
+        createdAt: string;
         /**
-         * List performance results for a profile
-         * @description Returns paginated load-test results associated with the performance profile identified by the path parameter.
+         * Format: date-time
+         * @description Timestamp when the performance profile was last updated.
          */
-        get: operations["getPerformanceProfileResults"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
+        updatedAt: string;
+      }[];
     };
-    "/api/performance/profiles/{performanceProfileId}/results/{resultId}": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
+    /** @description Load-test result captured for a Meshery performance profile. */
+    PerformanceResult: {
+      /**
+       * Format: uuid
+       * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+       */
+      mesheryId?: string;
+      /** @description Human-readable name of the performance result. */
+      name?: string;
+      /** @description Service mesh under test for this result. */
+      mesh?: string;
+      /**
+       * Format: uuid
+       * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+       */
+      performanceProfile?: string | null;
+      /** @description Provider-assigned test identifier for this result. */
+      testId?: string;
+      /** @description Raw load-generator output for this performance result. */
+      runnerResults?: { [key: string]: unknown };
+      /** @description Server-side metrics collected for this performance result. */
+      serverMetrics?: { [key: string]: unknown };
+      /** @description Server board configuration associated with this performance result. */
+      serverBoardConfig?: { [key: string]: unknown };
+      /**
+       * Format: date-time
+       * @description Time when the load test started.
+       */
+      testStartTime?: string;
+      /**
+       * Format: uuid
+       * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+       */
+      userId?: string;
+      /**
+       * Format: date-time
+       * @description Timestamp when the performance result was created.
+       */
+      createdAt?: string;
+      /**
+       * Format: date-time
+       * @description Timestamp when the performance result was last updated.
+       */
+      updatedAt?: string;
+    };
+    /** @description Paginated list of performance results. */
+    PerformanceResultPage: {
+      /** @description Zero-based page index returned in this response. */
+      page: number;
+      /** @description Maximum number of items returned on each page. */
+      pageSize: number;
+      /** @description Total number of performance results across all pages. */
+      totalCount: number;
+      /** @description Performance results in this page. */
+      results: {
         /**
-         * Get a performance result for a profile
-         * @description Returns one load-test result associated with the performance profile identified by the path parameter.
+         * Format: uuid
+         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
          */
-        get: operations["getPerformanceProfileResult"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-    "/api/performance/results": {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
+        mesheryId?: string;
+        /** @description Human-readable name of the performance result. */
+        name?: string;
+        /** @description Service mesh under test for this result. */
+        mesh?: string;
         /**
-         * List all performance results
-         * @description Returns paginated load-test results visible to the authenticated user.
+         * Format: uuid
+         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
          */
-        get: operations["getPerformanceResults"];
-        put?: never;
-        post?: never;
-        delete?: never;
-        options?: never;
-        head?: never;
-        patch?: never;
-        trace?: never;
-    };
-}
-export type webhooks = Record<string, never>;
-export interface components {
-    schemas: {
+        performanceProfile?: string | null;
+        /** @description Provider-assigned test identifier for this result. */
+        testId?: string;
+        /** @description Raw load-generator output for this performance result. */
+        runnerResults?: { [key: string]: unknown };
+        /** @description Server-side metrics collected for this performance result. */
+        serverMetrics?: { [key: string]: unknown };
+        /** @description Server board configuration associated with this performance result. */
+        serverBoardConfig?: { [key: string]: unknown };
+        /**
+         * Format: date-time
+         * @description Time when the load test started.
+         */
+        testStartTime?: string;
+        /**
+         * Format: uuid
+         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+         */
+        userId?: string;
+        /**
+         * Format: date-time
+         * @description Timestamp when the performance result was created.
+         */
+        createdAt?: string;
         /**
-         * PerformanceProfile
-         * @description A performance profile captures the configuration for a load test run by Meshery against one or more service-mesh endpoints. Profiles are owned by a user and can optionally be associated with a recurring schedule. Learn more at https://docs.meshery.io/tasks/performance-management
+         * Format: date-time
+         * @description Timestamp when the performance result was last updated.
          */
-        PerformanceProfile: {
+        updatedAt?: string;
+      }[];
+    };
+    /** @description Runtime configuration for a single performance (load) test run. This is the executable test definition that drives load generation, distinct from a saved PerformanceProfile. It is the Meshery-native replacement for the deprecated service-mesh-performance (SMP) PerformanceTestConfig. */
+    PerformanceTestConfig: {
+      /** @description Version of the performance test configuration format. */
+      smpVersion?: string;
+      /** @description Opaque identifier assigned to the persisted test configuration. Server-assigned (a UUID string); accepted as a free-form string for backward compatibility with externally authored test files. */
+      id?: string;
+      /** @description Human-readable name of the performance test. */
+      name: string;
+      /** @description Arbitrary key/value labels attached to the test configuration. */
+      labels?: { [key: string]: string };
+      /** @description Load-generation clients that issue requests during the test. A single client is typical; multiple clients describe a distributed load test. */
+      clients: {
+        /** @description Whether the client runs inside the cluster (internal) rather than against an external endpoint. */
+        internal?: boolean;
+        /** @description Load generator used to drive the test (e.g. "fortio"). Empty defaults to the server's supported generator. */
+        loadGenerator?: string;
+        /** @description Application protocol exercised by the client (e.g. "http", "tcp", "udp", "grpc"). */
+        protocol?: string;
+        /** @description Number of concurrent connections the client opens to the endpoint. */
+        connections?: number;
+        /** @description Target requests-per-second issued by the client. Zero means unthrottled. */
+        rps?: number;
+        /** @description HTTP request headers sent on each request. */
+        headers?: { [key: string]: string };
+        /** @description HTTP request cookies sent on each request. */
+        cookies?: { [key: string]: string };
+        /** @description Request body sent on each request. */
+        body?: string;
+        /** @description Content-Type header applied to the request body (e.g. "application/json"). */
+        contentType?: string;
+        /** @description Target endpoint URLs the client issues requests against. */
+        endpointUrls: string[];
+        /** @description PEM-encoded SSL certificate presented by the client, when required. */
+        sslCertificate?: string;
+        /** @description Additional load-generator-specific options passed through to the generator. */
+        additionalOptions?: string;
+      }[];
+      /** @description Length of time the endpoint is held under load, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+      duration: string;
+    };
+    /** @description A single load-generation client within a PerformanceTestConfig. It is the Meshery-native replacement for the deprecated service-mesh-performance (SMP) PerformanceTestConfig_Client. */
+    PerformanceTestClient: {
+      /** @description Whether the client runs inside the cluster (internal) rather than against an external endpoint. */
+      internal?: boolean;
+      /** @description Load generator used to drive the test (e.g. "fortio"). Empty defaults to the server's supported generator. */
+      loadGenerator?: string;
+      /** @description Application protocol exercised by the client (e.g. "http", "tcp", "udp", "grpc"). */
+      protocol?: string;
+      /** @description Number of concurrent connections the client opens to the endpoint. */
+      connections?: number;
+      /** @description Target requests-per-second issued by the client. Zero means unthrottled. */
+      rps?: number;
+      /** @description HTTP request headers sent on each request. */
+      headers?: { [key: string]: string };
+      /** @description HTTP request cookies sent on each request. */
+      cookies?: { [key: string]: string };
+      /** @description Request body sent on each request. */
+      body?: string;
+      /** @description Content-Type header applied to the request body (e.g. "application/json"). */
+      contentType?: string;
+      /** @description Target endpoint URLs the client issues requests against. */
+      endpointUrls: string[];
+      /** @description PEM-encoded SSL certificate presented by the client, when required. */
+      sslCertificate?: string;
+      /** @description Additional load-generator-specific options passed through to the generator. */
+      additionalOptions?: string;
+    };
+  };
+  responses: {
+    /** ok */
+    200: {
+      content: {
+        "text/plain": string;
+      };
+    };
+    /** Invalid request body or request param */
+    400: {
+      content: {
+        "text/plain": string;
+      };
+    };
+    /** Expired JWT token used or insufficient privilege */
+    401: {
+      content: {
+        "text/plain": string;
+      };
+    };
+    /** Result not found */
+    404: {
+      content: {
+        "text/plain": string;
+      };
+    };
+    /** Internal server error */
+    500: {
+      content: {
+        "text/plain": string;
+      };
+    };
+  };
+  parameters: {
+    /** @description Performance profile ID. */
+    performanceProfileId: string;
+    /** @description Performance result ID. */
+    resultId: string;
+    /** @description Get responses that match search param value */
+    search: string;
+    /** @description Get ordered responses */
+    order: string;
+    /** @description Get responses by page */
+    page: string;
+    /** @description Get responses by pagesize */
+    pagesize: string;
+    /** @description Start date for filtering results by test start time, in YYYY-MM-DD format. */
+    from: string;
+    /** @description End date for filtering results by test start time, in YYYY-MM-DD format. */
+    to: string;
+  };
+  requestBodies: {
+    /** Body for creating or updating a performance profile. */
+    performanceProfilePayload: {
+      content: {
+        "application/json": {
+          /**
+           * Format: uuid
+           * @description Existing performance-profile ID for updates; omit on create.
+           */
+          id?: string;
+          /** @description Human-readable name of the performance profile. */
+          name: string;
+          /**
+           * Format: uuid
+           * @description Owner user ID. When omitted, the server infers it from the authenticated user.
+           */
+          userId?: string;
+          /**
+           * Format: uuid
+           * @description Optional schedule ID associating the profile with a recurring run.
+           */
+          schedule?: string | null;
+          /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
+          loadGenerators: string[];
+          /** @description Endpoints (URLs) targeted by the performance profile's load test. */
+          endpoints: string[];
+          /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
+          serviceMesh?: string;
+          /** @description Number of concurrent requests issued by the load generator. */
+          concurrentRequest?: number;
+          /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
+          qps?: number;
+          /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+          duration: string;
+          /** @description HTTP request headers, serialized as JSON, sent on each load-test request. */
+          requestHeaders?: string;
+          /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. */
+          requestCookies?: string;
+          /** @description HTTP request body sent on each load-test request. */
+          requestBody?: string;
+          /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). */
+          contentType?: string;
+          /** @description Free-form metadata associated with the performance profile. */
+          metadata?: { [key: string]: unknown };
+        };
+      };
+    };
+  };
+}
+
+export interface operations {
+  /** Returns the performance profiles owned by the authenticated user, with pagination, search, and ordering. */
+  getPerformanceProfiles: {
+    parameters: {
+      query: {
+        /** Get responses by page */
+        page?: string;
+        /** Get responses by pagesize */
+        pagesize?: string;
+        /** Get responses that match search param value */
+        search?: string;
+        /** Get ordered responses */
+        order?: string;
+      };
+    };
+    responses: {
+      /** Performance profiles */
+      200: {
+        content: {
+          "application/json": {
+            /** @description Zero-based page index returned in this response. */
+            page: number;
+            /** @description Maximum number of items returned on each page. */
+            pageSize: number;
+            /** @description Total number of performance profiles across all pages. */
+            totalCount: number;
+            /** @description Performance profiles in this page. */
+            profiles: {
+              /**
+               * Format: uuid
+               * @description Unique identifier for the performance profile.
+               */
+              id: string;
+              /** @description Human-readable name of the performance profile. */
+              name: string;
+              /**
+               * Format: uuid
+               * @description User ID of the profile owner.
+               */
+              owner: string;
+              /**
+               * Format: uuid
+               * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
+               */
+              schedule?: string | null;
+              /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
+              loadGenerators?: string[];
+              /** @description Endpoints (URLs) targeted by the performance profile's load test. */
+              endpoints?: string[];
+              /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
+              serviceMesh?: string;
+              /** @description Number of concurrent requests issued by the load generator. */
+              concurrentRequest?: number;
+              /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
+              qps?: number;
+              /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+              duration?: string;
+              /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
+              requestHeaders?: string;
+              /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
+              requestCookies?: string;
+              /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
+              requestBody?: string;
+              /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
+              contentType?: string;
+              /** @description Free-form metadata associated with the performance profile. */
+              metadata?: { [key: string]: unknown };
+              /**
+               * Format: date-time
+               * @description 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;
+              /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
+              totalResults?: number;
+              /**
+               * Format: date-time
+               * @description Timestamp when the performance profile was created.
+               */
+              createdAt: string;
+              /**
+               * Format: date-time
+               * @description Timestamp when the performance profile was last updated.
+               */
+              updatedAt: string;
+            }[];
+          };
+        };
+      };
+      /** Invalid request body or request param */
+      400: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Expired JWT token used or insufficient privilege */
+      401: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Internal server error */
+      500: {
+        content: {
+          "text/plain": string;
+        };
+      };
+    };
+  };
+  /** Creates a new performance profile when the body omits id, or updates the matching existing profile when an id is provided. */
+  upsertPerformanceProfile: {
+    responses: {
+      /** Performance profile upserted */
+      200: {
+        content: {
+          "application/json": {
             /**
              * Format: uuid
              * @description Unique identifier for the performance profile.
@@ -136,7 +599,7 @@ export interface components {
              * Format: uuid
              * @description User ID of the profile owner.
              */
-            userId: string;
+            owner: string;
             /**
              * Format: uuid
              * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
@@ -163,9 +626,7 @@ export interface components {
             /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
             contentType?: string;
             /** @description Free-form metadata associated with the performance profile. */
-            metadata?: {
-                [key: string]: unknown;
-            };
+            metadata?: { [key: string]: unknown };
             /**
              * Format: date-time
              * @description 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.
@@ -183,30 +644,109 @@ export interface components {
              * @description Timestamp when the performance profile was last updated.
              */
             updatedAt: string;
+          };
+        };
+      };
+      /** Invalid request body or request param */
+      400: {
+        content: {
+          "text/plain": string;
         };
-        /** @description Payload for creating or updating a performance profile. Includes only client-settable fields; server-generated fields (id on create, createdAt, updatedAt, lastRun, totalResults) are populated by the server. */
-        PerformanceProfilePayload: {
+      };
+      /** Expired JWT token used or insufficient privilege */
+      401: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Internal server error */
+      500: {
+        content: {
+          "text/plain": string;
+        };
+      };
+    };
+    /** Body for creating or updating a performance profile. */
+    requestBody: {
+      content: {
+        "application/json": {
+          /**
+           * Format: uuid
+           * @description Existing performance-profile ID for updates; omit on create.
+           */
+          id?: string;
+          /** @description Human-readable name of the performance profile. */
+          name: string;
+          /**
+           * Format: uuid
+           * @description Owner user ID. When omitted, the server infers it from the authenticated user.
+           */
+          userId?: string;
+          /**
+           * Format: uuid
+           * @description Optional schedule ID associating the profile with a recurring run.
+           */
+          schedule?: string | null;
+          /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
+          loadGenerators: string[];
+          /** @description Endpoints (URLs) targeted by the performance profile's load test. */
+          endpoints: string[];
+          /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
+          serviceMesh?: string;
+          /** @description Number of concurrent requests issued by the load generator. */
+          concurrentRequest?: number;
+          /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
+          qps?: number;
+          /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+          duration: string;
+          /** @description HTTP request headers, serialized as JSON, sent on each load-test request. */
+          requestHeaders?: string;
+          /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. */
+          requestCookies?: string;
+          /** @description HTTP request body sent on each load-test request. */
+          requestBody?: string;
+          /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). */
+          contentType?: string;
+          /** @description Free-form metadata associated with the performance profile. */
+          metadata?: { [key: string]: unknown };
+        };
+      };
+    };
+  };
+  /** Returns a single performance profile owned by (or visible to) the authenticated user. */
+  getPerformanceProfile: {
+    parameters: {
+      path: {
+        /** Performance profile ID. */
+        performanceProfileId: string;
+      };
+    };
+    responses: {
+      /** Performance profile */
+      200: {
+        content: {
+          "application/json": {
             /**
              * Format: uuid
-             * @description Existing performance-profile ID for updates; omit on create.
+             * @description Unique identifier for the performance profile.
              */
-            id?: string;
+            id: string;
             /** @description Human-readable name of the performance profile. */
             name: string;
             /**
              * Format: uuid
-             * @description Owner user ID. When omitted, the server infers it from the authenticated user.
+             * @description User ID of the profile owner.
              */
-            userId?: string;
+            owner: string;
             /**
              * Format: uuid
-             * @description Optional schedule ID associating the profile with a recurring run.
+             * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
              */
             schedule?: string | null;
             /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-            loadGenerators: string[];
+            loadGenerators?: string[];
             /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-            endpoints: string[];
+            endpoints?: string[];
             /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
             serviceMesh?: string;
             /** @description Number of concurrent requests issued by the load generator. */
@@ -214,92 +754,362 @@ export interface components {
             /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
             qps?: number;
             /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-            duration: string;
-            /** @description HTTP request headers, serialized as JSON, sent on each load-test request. */
+            duration?: string;
+            /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
             requestHeaders?: string;
-            /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. */
+            /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
             requestCookies?: string;
-            /** @description HTTP request body sent on each load-test request. */
+            /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
             requestBody?: string;
-            /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). */
+            /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
             contentType?: string;
             /** @description Free-form metadata associated with the performance profile. */
-            metadata?: {
-                [key: string]: unknown;
-            };
+            metadata?: { [key: string]: unknown };
+            /**
+             * Format: date-time
+             * @description 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;
+            /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
+            totalResults?: number;
+            /**
+             * Format: date-time
+             * @description Timestamp when the performance profile was created.
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description Timestamp when the performance profile was last updated.
+             */
+            updatedAt: string;
+          };
         };
-        /** @description Paginated list of performance profiles. */
-        PerformanceProfilePage: {
+      };
+      /** Invalid request body or request param */
+      400: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Expired JWT token used or insufficient privilege */
+      401: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Result not found */
+      404: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Internal server error */
+      500: {
+        content: {
+          "text/plain": string;
+        };
+      };
+    };
+  };
+  /** Updates the performance profile identified by the path parameter. */
+  updatePerformanceProfile: {
+    parameters: {
+      path: {
+        /** Performance profile ID. */
+        performanceProfileId: string;
+      };
+    };
+    responses: {
+      /** Performance profile */
+      200: {
+        content: {
+          "application/json": {
+            /**
+             * Format: uuid
+             * @description Unique identifier for the performance profile.
+             */
+            id: string;
+            /** @description Human-readable name of the performance profile. */
+            name: string;
+            /**
+             * Format: uuid
+             * @description User ID of the profile owner.
+             */
+            owner: string;
+            /**
+             * Format: uuid
+             * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
+             */
+            schedule?: string | null;
+            /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
+            loadGenerators?: string[];
+            /** @description Endpoints (URLs) targeted by the performance profile's load test. */
+            endpoints?: string[];
+            /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
+            serviceMesh?: string;
+            /** @description Number of concurrent requests issued by the load generator. */
+            concurrentRequest?: number;
+            /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
+            qps?: number;
+            /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+            duration?: string;
+            /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
+            requestHeaders?: string;
+            /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
+            requestCookies?: string;
+            /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
+            requestBody?: string;
+            /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
+            contentType?: string;
+            /** @description Free-form metadata associated with the performance profile. */
+            metadata?: { [key: string]: unknown };
+            /**
+             * Format: date-time
+             * @description 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;
+            /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
+            totalResults?: number;
+            /**
+             * Format: date-time
+             * @description Timestamp when the performance profile was created.
+             */
+            createdAt: string;
+            /**
+             * Format: date-time
+             * @description Timestamp when the performance profile was last updated.
+             */
+            updatedAt: string;
+          };
+        };
+      };
+      /** Invalid request body or request param */
+      400: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Expired JWT token used or insufficient privilege */
+      401: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Result not found */
+      404: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Internal server error */
+      500: {
+        content: {
+          "text/plain": string;
+        };
+      };
+    };
+    /** Body for creating or updating a performance profile. */
+    requestBody: {
+      content: {
+        "application/json": {
+          /**
+           * Format: uuid
+           * @description Existing performance-profile ID for updates; omit on create.
+           */
+          id?: string;
+          /** @description Human-readable name of the performance profile. */
+          name: string;
+          /**
+           * Format: uuid
+           * @description Owner user ID. When omitted, the server infers it from the authenticated user.
+           */
+          userId?: string;
+          /**
+           * Format: uuid
+           * @description Optional schedule ID associating the profile with a recurring run.
+           */
+          schedule?: string | null;
+          /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
+          loadGenerators: string[];
+          /** @description Endpoints (URLs) targeted by the performance profile's load test. */
+          endpoints: string[];
+          /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
+          serviceMesh?: string;
+          /** @description Number of concurrent requests issued by the load generator. */
+          concurrentRequest?: number;
+          /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
+          qps?: number;
+          /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
+          duration: string;
+          /** @description HTTP request headers, serialized as JSON, sent on each load-test request. */
+          requestHeaders?: string;
+          /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. */
+          requestCookies?: string;
+          /** @description HTTP request body sent on each load-test request. */
+          requestBody?: string;
+          /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). */
+          contentType?: string;
+          /** @description Free-form metadata associated with the performance profile. */
+          metadata?: { [key: string]: unknown };
+        };
+      };
+    };
+  };
+  /** Deletes the performance profile identified by the path parameter and any associated performance results. */
+  deletePerformanceProfile: {
+    parameters: {
+      path: {
+        /** Performance profile ID. */
+        performanceProfileId: string;
+      };
+    };
+    responses: {
+      /** Performance profile deleted */
+      204: never;
+      /** Invalid request body or request param */
+      400: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Expired JWT token used or insufficient privilege */
+      401: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Result not found */
+      404: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Internal server error */
+      500: {
+        content: {
+          "text/plain": string;
+        };
+      };
+    };
+  };
+  /** Returns paginated load-test results associated with the performance profile identified by the path parameter. */
+  getPerformanceProfileResults: {
+    parameters: {
+      path: {
+        /** Performance profile ID. */
+        performanceProfileId: string;
+      };
+      query: {
+        /** Get responses by page */
+        page?: string;
+        /** Get responses by pagesize */
+        pagesize?: string;
+        /** Get responses that match search param value */
+        search?: string;
+        /** Get ordered responses */
+        order?: string;
+      };
+    };
+    responses: {
+      /** Performance results */
+      200: {
+        content: {
+          "application/json": {
             /** @description Zero-based page index returned in this response. */
             page: number;
             /** @description Maximum number of items returned on each page. */
             pageSize: number;
-            /** @description Total number of performance profiles across all pages. */
+            /** @description Total number of performance results across all pages. */
             totalCount: number;
-            /** @description Performance profiles in this page. */
-            profiles: {
-                /**
-                 * Format: uuid
-                 * @description Unique identifier for the performance profile.
-                 */
-                id: string;
-                /** @description Human-readable name of the performance profile. */
-                name: string;
-                /**
-                 * Format: uuid
-                 * @description User ID of the profile owner.
-                 */
-                userId: string;
-                /**
-                 * Format: uuid
-                 * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
-                 */
-                schedule?: string | null;
-                /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-                loadGenerators?: string[];
-                /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-                endpoints?: string[];
-                /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
-                serviceMesh?: string;
-                /** @description Number of concurrent requests issued by the load generator. */
-                concurrentRequest?: number;
-                /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
-                qps?: number;
-                /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-                duration?: string;
-                /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
-                requestHeaders?: string;
-                /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
-                requestCookies?: string;
-                /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
-                requestBody?: string;
-                /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
-                contentType?: string;
-                /** @description Free-form metadata associated with the performance profile. */
-                metadata?: {
-                    [key: string]: unknown;
-                };
-                /**
-                 * Format: date-time
-                 * @description 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;
-                /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
-                totalResults?: number;
-                /**
-                 * Format: date-time
-                 * @description Timestamp when the performance profile was created.
-                 */
-                createdAt: string;
-                /**
-                 * Format: date-time
-                 * @description Timestamp when the performance profile was last updated.
-                 */
-                updatedAt: string;
+            /** @description Performance results in this page. */
+            results: {
+              /**
+               * Format: uuid
+               * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+               */
+              mesheryId?: string;
+              /** @description Human-readable name of the performance result. */
+              name?: string;
+              /** @description Service mesh under test for this result. */
+              mesh?: string;
+              /**
+               * Format: uuid
+               * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+               */
+              performanceProfile?: string | null;
+              /** @description Provider-assigned test identifier for this result. */
+              testId?: string;
+              /** @description Raw load-generator output for this performance result. */
+              runnerResults?: { [key: string]: unknown };
+              /** @description Server-side metrics collected for this performance result. */
+              serverMetrics?: { [key: string]: unknown };
+              /** @description Server board configuration associated with this performance result. */
+              serverBoardConfig?: { [key: string]: unknown };
+              /**
+               * Format: date-time
+               * @description Time when the load test started.
+               */
+              testStartTime?: string;
+              /**
+               * Format: uuid
+               * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+               */
+              userId?: string;
+              /**
+               * Format: date-time
+               * @description Timestamp when the performance result was created.
+               */
+              createdAt?: string;
+              /**
+               * Format: date-time
+               * @description Timestamp when the performance result was last updated.
+               */
+              updatedAt?: string;
             }[];
+          };
+        };
+      };
+      /** Invalid request body or request param */
+      400: {
+        content: {
+          "text/plain": string;
         };
-        /** @description Load-test result captured for a Meshery performance profile. */
-        PerformanceResult: {
+      };
+      /** Expired JWT token used or insufficient privilege */
+      401: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Result not found */
+      404: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Internal server error */
+      500: {
+        content: {
+          "text/plain": string;
+        };
+      };
+    };
+  };
+  /** Returns one load-test result associated with the performance profile identified by the path parameter. */
+  getPerformanceProfileResult: {
+    parameters: {
+      path: {
+        /** Performance profile ID. */
+        performanceProfileId: string;
+        /** Performance result ID. */
+        resultId: string;
+      };
+    };
+    responses: {
+      /** Performance result */
+      200: {
+        content: {
+          "application/json": {
             /**
              * Format: uuid
              * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
@@ -317,17 +1127,11 @@ export interface components {
             /** @description Provider-assigned test identifier for this result. */
             testId?: string;
             /** @description Raw load-generator output for this performance result. */
-            runnerResults?: {
-                [key: string]: unknown;
-            };
+            runnerResults?: { [key: string]: unknown };
             /** @description Server-side metrics collected for this performance result. */
-            serverMetrics?: {
-                [key: string]: unknown;
-            };
+            serverMetrics?: { [key: string]: unknown };
             /** @description Server board configuration associated with this performance result. */
-            serverBoardConfig?: {
-                [key: string]: unknown;
-            };
+            serverBoardConfig?: { [key: string]: unknown };
             /**
              * Format: date-time
              * @description Time when the load test started.
@@ -348,9 +1152,58 @@ export interface components {
              * @description Timestamp when the performance result was last updated.
              */
             updatedAt?: string;
+          };
+        };
+      };
+      /** Invalid request body or request param */
+      400: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Expired JWT token used or insufficient privilege */
+      401: {
+        content: {
+          "text/plain": string;
+        };
+      };
+      /** Result not found */
+      404: {
+        content: {
+          "text/plain": string;
         };
-        /** @description Paginated list of performance results. */
-        PerformanceResultPage: {
+      };
+      /** Internal server error */
+      500: {
+        content: {
+          "text/plain": string;
+        };
+      };
+    };
+  };
+  /** Returns paginated load-test results visible to the authenticated user. */
+  getPerformanceResults: {
+    parameters: {
+      query: {
+        /** Get responses by page */
+        page?: string;
+        /** 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;
+      };
+    };
+    responses: {
+      /** Performance results */
+      200: {
+        content: {
+          "application/json": {
             /** @description Zero-based page index returned in this response. */
             page: number;
             /** @description Maximum number of items returned on each page. */
@@ -359,1223 +1212,72 @@ export interface components {
             totalCount: number;
             /** @description Performance results in this page. */
             results: {
-                /**
-                 * Format: uuid
-                 * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                 */
-                mesheryId?: string;
-                /** @description Human-readable name of the performance result. */
-                name?: string;
-                /** @description Service mesh under test for this result. */
-                mesh?: string;
-                /**
-                 * Format: uuid
-                 * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                 */
-                performanceProfile?: string | null;
-                /** @description Provider-assigned test identifier for this result. */
-                testId?: string;
-                /** @description Raw load-generator output for this performance result. */
-                runnerResults?: {
-                    [key: string]: unknown;
-                };
-                /** @description Server-side metrics collected for this performance result. */
-                serverMetrics?: {
-                    [key: string]: unknown;
-                };
-                /** @description Server board configuration associated with this performance result. */
-                serverBoardConfig?: {
-                    [key: string]: unknown;
-                };
-                /**
-                 * Format: date-time
-                 * @description Time when the load test started.
-                 */
-                testStartTime?: string;
-                /**
-                 * Format: uuid
-                 * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                 */
-                userId?: string;
-                /**
-                 * Format: date-time
-                 * @description Timestamp when the performance result was created.
-                 */
-                createdAt?: string;
-                /**
-                 * Format: date-time
-                 * @description Timestamp when the performance result was last updated.
-                 */
-                updatedAt?: string;
-            }[];
-        };
-        /** @description Runtime configuration for a single performance (load) test run. This is the executable test definition that drives load generation, distinct from a saved PerformanceProfile. It is the Meshery-native replacement for the deprecated service-mesh-performance (SMP) PerformanceTestConfig. */
-        PerformanceTestConfig: {
-            /** @description Version of the performance test configuration format. */
-            smpVersion?: string;
-            /** @description Opaque identifier assigned to the persisted test configuration. Server-assigned (a UUID string); accepted as a free-form string for backward compatibility with externally authored test files. */
-            id?: string;
-            /** @description Human-readable name of the performance test. */
-            name: string;
-            /** @description Arbitrary key/value labels attached to the test configuration. */
-            labels?: {
-                [key: string]: string;
-            };
-            /** @description Load-generation clients that issue requests during the test. A single client is typical; multiple clients describe a distributed load test. */
-            clients: {
-                /** @description Whether the client runs inside the cluster (internal) rather than against an external endpoint. */
-                internal?: boolean;
-                /** @description Load generator used to drive the test (e.g. "fortio"). Empty defaults to the server's supported generator. */
-                loadGenerator?: string;
-                /** @description Application protocol exercised by the client (e.g. "http", "tcp", "udp", "grpc"). */
-                protocol?: string;
-                /** @description Number of concurrent connections the client opens to the endpoint. */
-                connections?: number;
-                /** @description Target requests-per-second issued by the client. Zero means unthrottled. */
-                rps?: number;
-                /** @description HTTP request headers sent on each request. */
-                headers?: {
-                    [key: string]: string;
-                };
-                /** @description HTTP request cookies sent on each request. */
-                cookies?: {
-                    [key: string]: string;
-                };
-                /** @description Request body sent on each request. */
-                body?: string;
-                /** @description Content-Type header applied to the request body (e.g. "application/json"). */
-                contentType?: string;
-                /** @description Target endpoint URLs the client issues requests against. */
-                endpointUrls: string[];
-                /** @description PEM-encoded SSL certificate presented by the client, when required. */
-                sslCertificate?: string;
-                /** @description Additional load-generator-specific options passed through to the generator. */
-                additionalOptions?: string;
+              /**
+               * Format: uuid
+               * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+               */
+              mesheryId?: string;
+              /** @description Human-readable name of the performance result. */
+              name?: string;
+              /** @description Service mesh under test for this result. */
+              mesh?: string;
+              /**
+               * Format: uuid
+               * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+               */
+              performanceProfile?: string | null;
+              /** @description Provider-assigned test identifier for this result. */
+              testId?: string;
+              /** @description Raw load-generator output for this performance result. */
+              runnerResults?: { [key: string]: unknown };
+              /** @description Server-side metrics collected for this performance result. */
+              serverMetrics?: { [key: string]: unknown };
+              /** @description Server board configuration associated with this performance result. */
+              serverBoardConfig?: { [key: string]: unknown };
+              /**
+               * Format: date-time
+               * @description Time when the load test started.
+               */
+              testStartTime?: string;
+              /**
+               * Format: uuid
+               * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
+               */
+              userId?: string;
+              /**
+               * Format: date-time
+               * @description Timestamp when the performance result was created.
+               */
+              createdAt?: string;
+              /**
+               * Format: date-time
+               * @description Timestamp when the performance result was last updated.
+               */
+              updatedAt?: string;
             }[];
-            /** @description Length of time the endpoint is held under load, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-            duration: string;
+          };
         };
-        /** @description A single load-generation client within a PerformanceTestConfig. It is the Meshery-native replacement for the deprecated service-mesh-performance (SMP) PerformanceTestConfig_Client. */
-        PerformanceTestClient: {
-            /** @description Whether the client runs inside the cluster (internal) rather than against an external endpoint. */
-            internal?: boolean;
-            /** @description Load generator used to drive the test (e.g. "fortio"). Empty defaults to the server's supported generator. */
-            loadGenerator?: string;
-            /** @description Application protocol exercised by the client (e.g. "http", "tcp", "udp", "grpc"). */
-            protocol?: string;
-            /** @description Number of concurrent connections the client opens to the endpoint. */
-            connections?: number;
-            /** @description Target requests-per-second issued by the client. Zero means unthrottled. */
-            rps?: number;
-            /** @description HTTP request headers sent on each request. */
-            headers?: {
-                [key: string]: string;
-            };
-            /** @description HTTP request cookies sent on each request. */
-            cookies?: {
-                [key: string]: string;
-            };
-            /** @description Request body sent on each request. */
-            body?: string;
-            /** @description Content-Type header applied to the request body (e.g. "application/json"). */
-            contentType?: string;
-            /** @description Target endpoint URLs the client issues requests against. */
-            endpointUrls: string[];
-            /** @description PEM-encoded SSL certificate presented by the client, when required. */
-            sslCertificate?: string;
-            /** @description Additional load-generator-specific options passed through to the generator. */
-            additionalOptions?: string;
-        };
-    };
-    responses: {
-        /** @description ok */
-        200: {
-            headers: {
-                [name: string]: unknown;
-            };
-            content: {
-                "text/plain": string;
-            };
+      };
+      /** Invalid request body or request param */
+      400: {
+        content: {
+          "text/plain": string;
         };
-        /** @description Invalid request body or request param */
-        400: {
-            headers: {
-                [name: string]: unknown;
-            };
-            content: {
-                "text/plain": string;
-            };
+      };
+      /** Expired JWT token used or insufficient privilege */
+      401: {
+        content: {
+          "text/plain": string;
         };
-        /** @description Expired JWT token used or insufficient privilege */
-        401: {
-            headers: {
-                [name: string]: unknown;
-            };
-            content: {
-                "text/plain": string;
-            };
-        };
-        /** @description Result not found */
-        404: {
-            headers: {
-                [name: string]: unknown;
-            };
-            content: {
-                "text/plain": string;
-            };
-        };
-        /** @description Internal server error */
-        500: {
-            headers: {
-                [name: string]: unknown;
-            };
-            content: {
-                "text/plain": string;
-            };
-        };
-    };
-    parameters: {
-        /** @description Performance profile ID. */
-        performanceProfileId: string;
-        /** @description Performance result ID. */
-        resultId: string;
-        /** @description Get responses that match search param value */
-        search: string;
-        /** @description Get ordered responses */
-        order: string;
-        /** @description Get responses by page */
-        page: string;
-        /** @description Get responses by pagesize */
-        pagesize: string;
-        /** @description Start date for filtering results by test start time, in YYYY-MM-DD format. */
-        from: string;
-        /** @description End date for filtering results by test start time, in YYYY-MM-DD format. */
-        to: string;
-    };
-    requestBodies: {
-        /** @description Body for creating or updating a performance profile. */
-        performanceProfilePayload: {
-            content: {
-                "application/json": {
-                    /**
-                     * Format: uuid
-                     * @description Existing performance-profile ID for updates; omit on create.
-                     */
-                    id?: string;
-                    /** @description Human-readable name of the performance profile. */
-                    name: string;
-                    /**
-                     * Format: uuid
-                     * @description Owner user ID. When omitted, the server infers it from the authenticated user.
-                     */
-                    userId?: string;
-                    /**
-                     * Format: uuid
-                     * @description Optional schedule ID associating the profile with a recurring run.
-                     */
-                    schedule?: string | null;
-                    /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-                    loadGenerators: string[];
-                    /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-                    endpoints: string[];
-                    /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
-                    serviceMesh?: string;
-                    /** @description Number of concurrent requests issued by the load generator. */
-                    concurrentRequest?: number;
-                    /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
-                    qps?: number;
-                    /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-                    duration: string;
-                    /** @description HTTP request headers, serialized as JSON, sent on each load-test request. */
-                    requestHeaders?: string;
-                    /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. */
-                    requestCookies?: string;
-                    /** @description HTTP request body sent on each load-test request. */
-                    requestBody?: string;
-                    /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). */
-                    contentType?: string;
-                    /** @description Free-form metadata associated with the performance profile. */
-                    metadata?: {
-                        [key: string]: unknown;
-                    };
-                };
-            };
-        };
-    };
-    headers: never;
-    pathItems: never;
-}
-export type $defs = Record<string, never>;
-export interface operations {
-    getPerformanceProfiles: {
-        parameters: {
-            query?: {
-                /** @description Get responses by page */
-                page?: string;
-                /** @description Get responses by pagesize */
-                pagesize?: string;
-                /** @description Get responses that match search param value */
-                search?: string;
-                /** @description Get ordered responses */
-                order?: string;
-            };
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Performance profiles */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /** @description Zero-based page index returned in this response. */
-                        page: number;
-                        /** @description Maximum number of items returned on each page. */
-                        pageSize: number;
-                        /** @description Total number of performance profiles across all pages. */
-                        totalCount: number;
-                        /** @description Performance profiles in this page. */
-                        profiles: {
-                            /**
-                             * Format: uuid
-                             * @description Unique identifier for the performance profile.
-                             */
-                            id: string;
-                            /** @description Human-readable name of the performance profile. */
-                            name: string;
-                            /**
-                             * Format: uuid
-                             * @description User ID of the profile owner.
-                             */
-                            userId: string;
-                            /**
-                             * Format: uuid
-                             * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
-                             */
-                            schedule?: string | null;
-                            /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-                            loadGenerators?: string[];
-                            /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-                            endpoints?: string[];
-                            /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
-                            serviceMesh?: string;
-                            /** @description Number of concurrent requests issued by the load generator. */
-                            concurrentRequest?: number;
-                            /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
-                            qps?: number;
-                            /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-                            duration?: string;
-                            /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
-                            requestHeaders?: string;
-                            /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
-                            requestCookies?: string;
-                            /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
-                            requestBody?: string;
-                            /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
-                            contentType?: string;
-                            /** @description Free-form metadata associated with the performance profile. */
-                            metadata?: {
-                                [key: string]: unknown;
-                            };
-                            /**
-                             * Format: date-time
-                             * @description 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;
-                            /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
-                            totalResults?: number;
-                            /**
-                             * Format: date-time
-                             * @description Timestamp when the performance profile was created.
-                             */
-                            createdAt: string;
-                            /**
-                             * Format: date-time
-                             * @description Timestamp when the performance profile was last updated.
-                             */
-                            updatedAt: string;
-                        }[];
-                    };
-                };
-            };
-            /** @description Invalid request body or request param */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Expired JWT token used or insufficient privilege */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-        };
-    };
-    upsertPerformanceProfile: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        /** @description Body for creating or updating a performance profile. */
-        requestBody: {
-            content: {
-                "application/json": {
-                    /**
-                     * Format: uuid
-                     * @description Existing performance-profile ID for updates; omit on create.
-                     */
-                    id?: string;
-                    /** @description Human-readable name of the performance profile. */
-                    name: string;
-                    /**
-                     * Format: uuid
-                     * @description Owner user ID. When omitted, the server infers it from the authenticated user.
-                     */
-                    userId?: string;
-                    /**
-                     * Format: uuid
-                     * @description Optional schedule ID associating the profile with a recurring run.
-                     */
-                    schedule?: string | null;
-                    /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-                    loadGenerators: string[];
-                    /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-                    endpoints: string[];
-                    /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
-                    serviceMesh?: string;
-                    /** @description Number of concurrent requests issued by the load generator. */
-                    concurrentRequest?: number;
-                    /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
-                    qps?: number;
-                    /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-                    duration: string;
-                    /** @description HTTP request headers, serialized as JSON, sent on each load-test request. */
-                    requestHeaders?: string;
-                    /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. */
-                    requestCookies?: string;
-                    /** @description HTTP request body sent on each load-test request. */
-                    requestBody?: string;
-                    /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). */
-                    contentType?: string;
-                    /** @description Free-form metadata associated with the performance profile. */
-                    metadata?: {
-                        [key: string]: unknown;
-                    };
-                };
-            };
-        };
-        responses: {
-            /** @description Performance profile upserted */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /**
-                         * Format: uuid
-                         * @description Unique identifier for the performance profile.
-                         */
-                        id: string;
-                        /** @description Human-readable name of the performance profile. */
-                        name: string;
-                        /**
-                         * Format: uuid
-                         * @description User ID of the profile owner.
-                         */
-                        userId: string;
-                        /**
-                         * Format: uuid
-                         * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
-                         */
-                        schedule?: string | null;
-                        /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-                        loadGenerators?: string[];
-                        /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-                        endpoints?: string[];
-                        /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
-                        serviceMesh?: string;
-                        /** @description Number of concurrent requests issued by the load generator. */
-                        concurrentRequest?: number;
-                        /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
-                        qps?: number;
-                        /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-                        duration?: string;
-                        /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
-                        requestHeaders?: string;
-                        /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
-                        requestCookies?: string;
-                        /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
-                        requestBody?: string;
-                        /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
-                        contentType?: string;
-                        /** @description Free-form metadata associated with the performance profile. */
-                        metadata?: {
-                            [key: string]: unknown;
-                        };
-                        /**
-                         * Format: date-time
-                         * @description 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;
-                        /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
-                        totalResults?: number;
-                        /**
-                         * Format: date-time
-                         * @description Timestamp when the performance profile was created.
-                         */
-                        createdAt: string;
-                        /**
-                         * Format: date-time
-                         * @description Timestamp when the performance profile was last updated.
-                         */
-                        updatedAt: string;
-                    };
-                };
-            };
-            /** @description Invalid request body or request param */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Expired JWT token used or insufficient privilege */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-        };
-    };
-    getPerformanceProfile: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                /** @description Performance profile ID. */
-                performanceProfileId: string;
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Performance profile */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /**
-                         * Format: uuid
-                         * @description Unique identifier for the performance profile.
-                         */
-                        id: string;
-                        /** @description Human-readable name of the performance profile. */
-                        name: string;
-                        /**
-                         * Format: uuid
-                         * @description User ID of the profile owner.
-                         */
-                        userId: string;
-                        /**
-                         * Format: uuid
-                         * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
-                         */
-                        schedule?: string | null;
-                        /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-                        loadGenerators?: string[];
-                        /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-                        endpoints?: string[];
-                        /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
-                        serviceMesh?: string;
-                        /** @description Number of concurrent requests issued by the load generator. */
-                        concurrentRequest?: number;
-                        /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
-                        qps?: number;
-                        /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-                        duration?: string;
-                        /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
-                        requestHeaders?: string;
-                        /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
-                        requestCookies?: string;
-                        /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
-                        requestBody?: string;
-                        /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
-                        contentType?: string;
-                        /** @description Free-form metadata associated with the performance profile. */
-                        metadata?: {
-                            [key: string]: unknown;
-                        };
-                        /**
-                         * Format: date-time
-                         * @description 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;
-                        /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
-                        totalResults?: number;
-                        /**
-                         * Format: date-time
-                         * @description Timestamp when the performance profile was created.
-                         */
-                        createdAt: string;
-                        /**
-                         * Format: date-time
-                         * @description Timestamp when the performance profile was last updated.
-                         */
-                        updatedAt: string;
-                    };
-                };
-            };
-            /** @description Invalid request body or request param */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Expired JWT token used or insufficient privilege */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Result not found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-        };
-    };
-    updatePerformanceProfile: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                /** @description Performance profile ID. */
-                performanceProfileId: string;
-            };
-            cookie?: never;
-        };
-        /** @description Body for creating or updating a performance profile. */
-        requestBody: {
-            content: {
-                "application/json": {
-                    /**
-                     * Format: uuid
-                     * @description Existing performance-profile ID for updates; omit on create.
-                     */
-                    id?: string;
-                    /** @description Human-readable name of the performance profile. */
-                    name: string;
-                    /**
-                     * Format: uuid
-                     * @description Owner user ID. When omitted, the server infers it from the authenticated user.
-                     */
-                    userId?: string;
-                    /**
-                     * Format: uuid
-                     * @description Optional schedule ID associating the profile with a recurring run.
-                     */
-                    schedule?: string | null;
-                    /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-                    loadGenerators: string[];
-                    /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-                    endpoints: string[];
-                    /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
-                    serviceMesh?: string;
-                    /** @description Number of concurrent requests issued by the load generator. */
-                    concurrentRequest?: number;
-                    /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
-                    qps?: number;
-                    /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-                    duration: string;
-                    /** @description HTTP request headers, serialized as JSON, sent on each load-test request. */
-                    requestHeaders?: string;
-                    /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. */
-                    requestCookies?: string;
-                    /** @description HTTP request body sent on each load-test request. */
-                    requestBody?: string;
-                    /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). */
-                    contentType?: string;
-                    /** @description Free-form metadata associated with the performance profile. */
-                    metadata?: {
-                        [key: string]: unknown;
-                    };
-                };
-            };
-        };
-        responses: {
-            /** @description Performance profile */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /**
-                         * Format: uuid
-                         * @description Unique identifier for the performance profile.
-                         */
-                        id: string;
-                        /** @description Human-readable name of the performance profile. */
-                        name: string;
-                        /**
-                         * Format: uuid
-                         * @description User ID of the profile owner.
-                         */
-                        userId: string;
-                        /**
-                         * Format: uuid
-                         * @description Optional schedule ID associated with this performance profile. Null when the profile is not bound to a recurring schedule.
-                         */
-                        schedule?: string | null;
-                        /** @description Load generators (e.g. fortio, wrk2, nighthawk) to drive the profile's load test. */
-                        loadGenerators?: string[];
-                        /** @description Endpoints (URLs) targeted by the performance profile's load test. */
-                        endpoints?: string[];
-                        /** @description Service mesh under test for the profile (e.g. istio, linkerd, consul). Empty string when the profile is mesh-agnostic. */
-                        serviceMesh?: string;
-                        /** @description Number of concurrent requests issued by the load generator. */
-                        concurrentRequest?: number;
-                        /** @description Target queries-per-second rate for the load generator. Zero indicates the generator runs unthrottled. */
-                        qps?: number;
-                        /** @description Duration of the load test, expressed as a Go duration string (e.g. "30s", "5m", "1h"). */
-                        duration?: string;
-                        /** @description HTTP request headers, serialized as JSON, sent on each load-test request. Empty string when no headers are configured. */
-                        requestHeaders?: string;
-                        /** @description HTTP request cookies, serialized as JSON, sent on each load-test request. Empty string when no cookies are configured. */
-                        requestCookies?: string;
-                        /** @description HTTP request body sent on each load-test request. Empty string when no body is configured. */
-                        requestBody?: string;
-                        /** @description Content-Type header value applied to each load-test request body (e.g. "application/json"). Empty string when no body is configured. */
-                        contentType?: string;
-                        /** @description Free-form metadata associated with the performance profile. */
-                        metadata?: {
-                            [key: string]: unknown;
-                        };
-                        /**
-                         * Format: date-time
-                         * @description 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;
-                        /** @description Server-computed count of load-test results recorded for this profile. Server-managed; clients must not set this on create/update. */
-                        totalResults?: number;
-                        /**
-                         * Format: date-time
-                         * @description Timestamp when the performance profile was created.
-                         */
-                        createdAt: string;
-                        /**
-                         * Format: date-time
-                         * @description Timestamp when the performance profile was last updated.
-                         */
-                        updatedAt: string;
-                    };
-                };
-            };
-            /** @description Invalid request body or request param */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Expired JWT token used or insufficient privilege */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Result not found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-        };
-    };
-    deletePerformanceProfile: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                /** @description Performance profile ID. */
-                performanceProfileId: string;
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Performance profile deleted */
-            204: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content?: never;
-            };
-            /** @description Invalid request body or request param */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Expired JWT token used or insufficient privilege */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Result not found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-        };
-    };
-    getPerformanceProfileResults: {
-        parameters: {
-            query?: {
-                /** @description Get responses by page */
-                page?: string;
-                /** @description Get responses by pagesize */
-                pagesize?: string;
-                /** @description Get responses that match search param value */
-                search?: string;
-                /** @description Get ordered responses */
-                order?: string;
-            };
-            header?: never;
-            path: {
-                /** @description Performance profile ID. */
-                performanceProfileId: string;
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Performance results */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /** @description Zero-based page index returned in this response. */
-                        page: number;
-                        /** @description Maximum number of items returned on each page. */
-                        pageSize: number;
-                        /** @description Total number of performance results across all pages. */
-                        totalCount: number;
-                        /** @description Performance results in this page. */
-                        results: {
-                            /**
-                             * Format: uuid
-                             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                             */
-                            mesheryId?: string;
-                            /** @description Human-readable name of the performance result. */
-                            name?: string;
-                            /** @description Service mesh under test for this result. */
-                            mesh?: string;
-                            /**
-                             * Format: uuid
-                             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                             */
-                            performanceProfile?: string | null;
-                            /** @description Provider-assigned test identifier for this result. */
-                            testId?: string;
-                            /** @description Raw load-generator output for this performance result. */
-                            runnerResults?: {
-                                [key: string]: unknown;
-                            };
-                            /** @description Server-side metrics collected for this performance result. */
-                            serverMetrics?: {
-                                [key: string]: unknown;
-                            };
-                            /** @description Server board configuration associated with this performance result. */
-                            serverBoardConfig?: {
-                                [key: string]: unknown;
-                            };
-                            /**
-                             * Format: date-time
-                             * @description Time when the load test started.
-                             */
-                            testStartTime?: string;
-                            /**
-                             * Format: uuid
-                             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                             */
-                            userId?: string;
-                            /**
-                             * Format: date-time
-                             * @description Timestamp when the performance result was created.
-                             */
-                            createdAt?: string;
-                            /**
-                             * Format: date-time
-                             * @description Timestamp when the performance result was last updated.
-                             */
-                            updatedAt?: string;
-                        }[];
-                    };
-                };
-            };
-            /** @description Invalid request body or request param */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Expired JWT token used or insufficient privilege */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Result not found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-        };
-    };
-    getPerformanceProfileResult: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                /** @description Performance profile ID. */
-                performanceProfileId: string;
-                /** @description Performance result ID. */
-                resultId: string;
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Performance result */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /**
-                         * Format: uuid
-                         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                         */
-                        mesheryId?: string;
-                        /** @description Human-readable name of the performance result. */
-                        name?: string;
-                        /** @description Service mesh under test for this result. */
-                        mesh?: string;
-                        /**
-                         * Format: uuid
-                         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                         */
-                        performanceProfile?: string | null;
-                        /** @description Provider-assigned test identifier for this result. */
-                        testId?: string;
-                        /** @description Raw load-generator output for this performance result. */
-                        runnerResults?: {
-                            [key: string]: unknown;
-                        };
-                        /** @description Server-side metrics collected for this performance result. */
-                        serverMetrics?: {
-                            [key: string]: unknown;
-                        };
-                        /** @description Server board configuration associated with this performance result. */
-                        serverBoardConfig?: {
-                            [key: string]: unknown;
-                        };
-                        /**
-                         * Format: date-time
-                         * @description Time when the load test started.
-                         */
-                        testStartTime?: string;
-                        /**
-                         * Format: uuid
-                         * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                         */
-                        userId?: string;
-                        /**
-                         * Format: date-time
-                         * @description Timestamp when the performance result was created.
-                         */
-                        createdAt?: string;
-                        /**
-                         * Format: date-time
-                         * @description Timestamp when the performance result was last updated.
-                         */
-                        updatedAt?: string;
-                    };
-                };
-            };
-            /** @description Invalid request body or request param */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Expired JWT token used or insufficient privilege */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Result not found */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-        };
-    };
-    getPerformanceResults: {
-        parameters: {
-            query?: {
-                /** @description Get responses by page */
-                page?: string;
-                /** @description Get responses by pagesize */
-                pagesize?: string;
-                /** @description Get responses that match search param value */
-                search?: string;
-                /** @description Get ordered responses */
-                order?: string;
-                /** @description Start date for filtering results by test start time, in YYYY-MM-DD format. */
-                from?: string;
-                /** @description End date for filtering results by test start time, in YYYY-MM-DD format. */
-                to?: string;
-            };
-            header?: never;
-            path?: never;
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description Performance results */
-            200: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": {
-                        /** @description Zero-based page index returned in this response. */
-                        page: number;
-                        /** @description Maximum number of items returned on each page. */
-                        pageSize: number;
-                        /** @description Total number of performance results across all pages. */
-                        totalCount: number;
-                        /** @description Performance results in this page. */
-                        results: {
-                            /**
-                             * Format: uuid
-                             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                             */
-                            mesheryId?: string;
-                            /** @description Human-readable name of the performance result. */
-                            name?: string;
-                            /** @description Service mesh under test for this result. */
-                            mesh?: string;
-                            /**
-                             * Format: uuid
-                             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                             */
-                            performanceProfile?: string | null;
-                            /** @description Provider-assigned test identifier for this result. */
-                            testId?: string;
-                            /** @description Raw load-generator output for this performance result. */
-                            runnerResults?: {
-                                [key: string]: unknown;
-                            };
-                            /** @description Server-side metrics collected for this performance result. */
-                            serverMetrics?: {
-                                [key: string]: unknown;
-                            };
-                            /** @description Server board configuration associated with this performance result. */
-                            serverBoardConfig?: {
-                                [key: string]: unknown;
-                            };
-                            /**
-                             * Format: date-time
-                             * @description Time when the load test started.
-                             */
-                            testStartTime?: string;
-                            /**
-                             * Format: uuid
-                             * @description A Universally Unique Identifier used to uniquely identify entities in Meshery. The UUID core definition is used across different schemas.
-                             */
-                            userId?: string;
-                            /**
-                             * Format: date-time
-                             * @description Timestamp when the performance result was created.
-                             */
-                            createdAt?: string;
-                            /**
-                             * Format: date-time
-                             * @description Timestamp when the performance result was last updated.
-                             */
-                            updatedAt?: string;
-                        }[];
-                    };
-                };
-            };
-            /** @description Invalid request body or request param */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Expired JWT token used or insufficient privilege */
-            401: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
-            /** @description Internal server error */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "text/plain": string;
-                };
-            };
+      };
+      /** Internal server error */
+      500: {
+        content: {
+          "text/plain": string;
         };
+      };
     };
+  };
 }
+
+export interface external {}