@openshift-migration-advisor/planner-sdk 0.6.0 → 0.7.0-4ccf2aa66adf

package/docs/MigrationComplexityResponse.md

@@ -0,0 +1,43 @@
+
+# MigrationComplexityResponse
+
+Migration complexity estimation results
+
+## Properties
+
+Name | Type
+------------ | -------------
+`complexityByDisk` | [Array<ComplexityDiskScoreEntry>](ComplexityDiskScoreEntry.md)
+`complexityByOS` | [Array<ComplexityOSScoreEntry>](ComplexityOSScoreEntry.md)
+`diskSizeRatings` | { [key: string]: number; }
+`osRatings` | { [key: string]: number; }
+`complexityByOSName` | [Array<ComplexityOSNameEntry>](ComplexityOSNameEntry.md)
+
+## Example
+
+```typescript
+import type { MigrationComplexityResponse } from '@openshift-migration-advisor/planner-sdk'
+
+// TODO: Update the object below with actual values
+const example = {
+  "complexityByDisk": null,
+  "complexityByOS": null,
+  "diskSizeRatings": null,
+  "osRatings": null,
+  "complexityByOSName": null,
+} satisfies MigrationComplexityResponse
+
+console.log(example)
+
+// Convert the instance to a JSON string
+const exampleJSON: string = JSON.stringify(example)
+console.log(exampleJSON)
+
+// Parse the JSON string back to an object
+const exampleParsed = JSON.parse(exampleJSON) as MigrationComplexityResponse
+console.log(exampleParsed)
+```
+
+[[Back to top]](#) [[Back to API list]](../README.md#api-endpoints) [[Back to Model list]](../README.md#models) [[Back to README]](../README.md)
+
+

package/docs/VMs.md

@@ -16,6 +16,7 @@ Name | Type
 `distributionByCpuTier` | { [key: string]: number; }
 `distributionByMemoryTier` | { [key: string]: number; }
 `distributionByNicCount` | { [key: string]: number; }
+`distributionByComplexity` | { [key: string]: number; }
 `ramGB` | [VMResourceBreakdown](VMResourceBreakdown.md)
 `diskGB` | [VMResourceBreakdown](VMResourceBreakdown.md)
 `diskCount` | [VMResourceBreakdown](VMResourceBreakdown.md)
@@ -43,6 +44,7 @@ const example = {
   "distributionByCpuTier": null,
   "distributionByMemoryTier": null,
   "distributionByNicCount": null,
+  "distributionByComplexity": null,
   "ramGB": null,
   "diskGB": null,
   "diskCount": null,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openshift-migration-advisor/planner-sdk",
-  "version": "0.6.0",
+  "version": "0.7.0-4ccf2aa66adf",
   "description": "OpenAPI client for @openshift-migration-advisor/planner-sdk",
   "author": "OpenAPI-Generator",
   "repository": {

package/src/apis/AssessmentApi.ts

@@ -20,6 +20,8 @@ import type {
   AssessmentUpdate,
   ClusterRequirementsRequest,
   ClusterRequirementsResponse,
+  MigrationComplexityRequest,
+  MigrationComplexityResponse,
   MigrationEstimationRequest,
   MigrationEstimationResponse,
 } from '../models/index.js';
@@ -34,6 +36,10 @@ import {
     ClusterRequirementsRequestToJSON,
     ClusterRequirementsResponseFromJSON,
     ClusterRequirementsResponseToJSON,
+    MigrationComplexityRequestFromJSON,
+    MigrationComplexityRequestToJSON,
+    MigrationComplexityResponseFromJSON,
+    MigrationComplexityResponseToJSON,
     MigrationEstimationRequestFromJSON,
     MigrationEstimationRequestToJSON,
     MigrationEstimationResponseFromJSON,
@@ -45,6 +51,11 @@ export interface CalculateAssessmentClusterRequirementsRequest {
     clusterRequirementsRequest: ClusterRequirementsRequest;
 }
 
+export interface CalculateMigrationComplexityRequest {
+    id: string;
+    migrationComplexityRequest: MigrationComplexityRequest;
+}
+
 export interface CalculateMigrationEstimationRequest {
     id: string;
     migrationEstimationRequest: MigrationEstimationRequest;
@@ -102,6 +113,30 @@ export interface AssessmentApiInterface {
      */
     calculateAssessmentClusterRequirements(requestParameters: CalculateAssessmentClusterRequirementsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ClusterRequirementsResponse>;
 
+    /**
+     * Creates request options for calculateMigrationComplexity without sending the request
+     * @param {string} id ID of the assessment
+     * @param {MigrationComplexityRequest} migrationComplexityRequest 
+     * @throws {RequiredError}
+     * @memberof AssessmentApiInterface
+     */
+    calculateMigrationComplexityRequestOpts(requestParameters: CalculateMigrationComplexityRequest): Promise<runtime.RequestOpts>;
+
+    /**
+     * Calculate migration complexity estimation for an assessment cluster
+     * @param {string} id ID of the assessment
+     * @param {MigrationComplexityRequest} migrationComplexityRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AssessmentApiInterface
+     */
+    calculateMigrationComplexityRaw(requestParameters: CalculateMigrationComplexityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MigrationComplexityResponse>>;
+
+    /**
+     * Calculate migration complexity estimation for an assessment cluster
+     */
+    calculateMigrationComplexity(requestParameters: CalculateMigrationComplexityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MigrationComplexityResponse>;
+
     /**
      * Creates request options for calculateMigrationEstimation without sending the request
      * @param {string} id ID of the assessment
@@ -300,6 +335,61 @@ export class AssessmentApi extends runtime.BaseAPI implements AssessmentApiInter
         return await response.value();
     }
 
+    /**
+     * Creates request options for calculateMigrationComplexity without sending the request
+     */
+    async calculateMigrationComplexityRequestOpts(requestParameters: CalculateMigrationComplexityRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling calculateMigrationComplexity().'
+            );
+        }
+
+        if (requestParameters['migrationComplexityRequest'] == null) {
+            throw new runtime.RequiredError(
+                'migrationComplexityRequest',
+                'Required parameter "migrationComplexityRequest" was null or undefined when calling calculateMigrationComplexity().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/api/v1/assessments/{id}/complexity-estimation`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: MigrationComplexityRequestToJSON(requestParameters['migrationComplexityRequest']),
+        };
+    }
+
+    /**
+     * Calculate migration complexity estimation for an assessment cluster
+     */
+    async calculateMigrationComplexityRaw(requestParameters: CalculateMigrationComplexityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MigrationComplexityResponse>> {
+        const requestOptions = await this.calculateMigrationComplexityRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => MigrationComplexityResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Calculate migration complexity estimation for an assessment cluster
+     */
+    async calculateMigrationComplexity(requestParameters: CalculateMigrationComplexityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MigrationComplexityResponse> {
+        const response = await this.calculateMigrationComplexityRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for calculateMigrationEstimation without sending the request
      */

package/src/models/ClusterRequirementsRequest.ts

@@ -73,6 +73,12 @@ export interface ClusterRequirementsRequest {
      * @memberof ClusterRequirementsRequest
      */
     controlPlaneMemory?: number;
+    /**
+     * Number of control plane nodes (1 for single node, 3 for HA)
+     * @type {ClusterRequirementsRequestControlPlaneNodeCountEnum}
+     * @memberof ClusterRequirementsRequest
+     */
+    controlPlaneNodeCount?: ClusterRequirementsRequestControlPlaneNodeCountEnum;
 }
 
 
@@ -97,6 +103,15 @@ export const ClusterRequirementsRequestMemoryOverCommitRatioEnum = {
 } as const;
 export type ClusterRequirementsRequestMemoryOverCommitRatioEnum = typeof ClusterRequirementsRequestMemoryOverCommitRatioEnum[keyof typeof ClusterRequirementsRequestMemoryOverCommitRatioEnum];
 
+/**
+ * @export
+ */
+export const ClusterRequirementsRequestControlPlaneNodeCountEnum = {
+    NUMBER_1: 1,
+    NUMBER_3: 3
+} as const;
+export type ClusterRequirementsRequestControlPlaneNodeCountEnum = typeof ClusterRequirementsRequestControlPlaneNodeCountEnum[keyof typeof ClusterRequirementsRequestControlPlaneNodeCountEnum];
+
 
 /**
  * Check if a given object implements the ClusterRequirementsRequest interface.
@@ -129,6 +144,7 @@ export function ClusterRequirementsRequestFromJSONTyped(json: any, ignoreDiscrim
         'controlPlaneSchedulable': json['controlPlaneSchedulable'] == null ? undefined : json['controlPlaneSchedulable'],
         'controlPlaneCPU': json['controlPlaneCPU'] == null ? undefined : json['controlPlaneCPU'],
         'controlPlaneMemory': json['controlPlaneMemory'] == null ? undefined : json['controlPlaneMemory'],
+        'controlPlaneNodeCount': json['controlPlaneNodeCount'] == null ? undefined : json['controlPlaneNodeCount'],
     };
 }
 
@@ -152,6 +168,7 @@ export function ClusterRequirementsRequestToJSONTyped(value?: ClusterRequirement
         'controlPlaneSchedulable': value['controlPlaneSchedulable'],
         'controlPlaneCPU': value['controlPlaneCPU'],
         'controlPlaneMemory': value['controlPlaneMemory'],
+        'controlPlaneNodeCount': value['controlPlaneNodeCount'],
     };
 }
 

package/src/models/ComplexityDiskScoreEntry.ts

@@ -0,0 +1,85 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenShift Migration Advisor API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: undefined
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime.js';
+/**
+ * One entry in the disk complexity breakdown
+ * @export
+ * @interface ComplexityDiskScoreEntry
+ */
+export interface ComplexityDiskScoreEntry {
+    /**
+     * Complexity score from 1 to 4, where 1 is the least complex disk footprint and 4 is the most complex. Score 1: <=10 TB provisioned; score 2: <=20 TB; score 3: <=50 TB; score 4: >50 TB.
+     * 
+     * @type {number}
+     * @memberof ComplexityDiskScoreEntry
+     */
+    score: number;
+    /**
+     * Number of VMs at this complexity score
+     * @type {number}
+     * @memberof ComplexityDiskScoreEntry
+     */
+    vmCount: number;
+    /**
+     * Total provisioned storage in TB for VMs at this score
+     * @type {number}
+     * @memberof ComplexityDiskScoreEntry
+     */
+    totalSizeTB: number;
+}
+
+/**
+ * Check if a given object implements the ComplexityDiskScoreEntry interface.
+ */
+export function instanceOfComplexityDiskScoreEntry(value: object): value is ComplexityDiskScoreEntry {
+    if (!('score' in value) || value['score'] === undefined) return false;
+    if (!('vmCount' in value) || value['vmCount'] === undefined) return false;
+    if (!('totalSizeTB' in value) || value['totalSizeTB'] === undefined) return false;
+    return true;
+}
+
+export function ComplexityDiskScoreEntryFromJSON(json: any): ComplexityDiskScoreEntry {
+    return ComplexityDiskScoreEntryFromJSONTyped(json, false);
+}
+
+export function ComplexityDiskScoreEntryFromJSONTyped(json: any, ignoreDiscriminator: boolean): ComplexityDiskScoreEntry {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'score': json['score'],
+        'vmCount': json['vmCount'],
+        'totalSizeTB': json['totalSizeTB'],
+    };
+}
+
+export function ComplexityDiskScoreEntryToJSON(json: any): ComplexityDiskScoreEntry {
+    return ComplexityDiskScoreEntryToJSONTyped(json, false);
+}
+
+export function ComplexityDiskScoreEntryToJSONTyped(value?: ComplexityDiskScoreEntry | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'score': value['score'],
+        'vmCount': value['vmCount'],
+        'totalSizeTB': value['totalSizeTB'],
+    };
+}
+

package/src/models/ComplexityOSNameEntry.ts

@@ -0,0 +1,86 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenShift Migration Advisor API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: undefined
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime.js';
+/**
+ * One entry in the per-OS-name complexity breakdown.
+ * @export
+ * @interface ComplexityOSNameEntry
+ */
+export interface ComplexityOSNameEntry {
+    /**
+     * The OS name exactly as it appears in vms.osInfo (e.g. "Red Hat Enterprise Linux 9 (64-bit)").
+     * 
+     * @type {string}
+     * @memberof ComplexityOSNameEntry
+     */
+    osName: string;
+    /**
+     * Complexity score assigned by ClassifyOS. 0 = unclassified, 1 = least complex, 4 = most complex.
+     * 
+     * @type {number}
+     * @memberof ComplexityOSNameEntry
+     */
+    score: number;
+    /**
+     * Number of VMs running this OS.
+     * @type {number}
+     * @memberof ComplexityOSNameEntry
+     */
+    vmCount: number;
+}
+
+/**
+ * Check if a given object implements the ComplexityOSNameEntry interface.
+ */
+export function instanceOfComplexityOSNameEntry(value: object): value is ComplexityOSNameEntry {
+    if (!('osName' in value) || value['osName'] === undefined) return false;
+    if (!('score' in value) || value['score'] === undefined) return false;
+    if (!('vmCount' in value) || value['vmCount'] === undefined) return false;
+    return true;
+}
+
+export function ComplexityOSNameEntryFromJSON(json: any): ComplexityOSNameEntry {
+    return ComplexityOSNameEntryFromJSONTyped(json, false);
+}
+
+export function ComplexityOSNameEntryFromJSONTyped(json: any, ignoreDiscriminator: boolean): ComplexityOSNameEntry {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'osName': json['osName'],
+        'score': json['score'],
+        'vmCount': json['vmCount'],
+    };
+}
+
+export function ComplexityOSNameEntryToJSON(json: any): ComplexityOSNameEntry {
+    return ComplexityOSNameEntryToJSONTyped(json, false);
+}
+
+export function ComplexityOSNameEntryToJSONTyped(value?: ComplexityOSNameEntry | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'osName': value['osName'],
+        'score': value['score'],
+        'vmCount': value['vmCount'],
+    };
+}
+

package/src/models/ComplexityOSScoreEntry.ts

@@ -0,0 +1,76 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenShift Migration Advisor API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: undefined
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime.js';
+/**
+ * One entry in the OS complexity breakdown
+ * @export
+ * @interface ComplexityOSScoreEntry
+ */
+export interface ComplexityOSScoreEntry {
+    /**
+     * Complexity score from 0 to 4, where 1 indicates the least complex OS to migrate and 0 indicates an OS that could not be classified.
+     * 
+     * @type {number}
+     * @memberof ComplexityOSScoreEntry
+     */
+    score: number;
+    /**
+     * Number of VMs at this complexity score
+     * @type {number}
+     * @memberof ComplexityOSScoreEntry
+     */
+    vmCount: number;
+}
+
+/**
+ * Check if a given object implements the ComplexityOSScoreEntry interface.
+ */
+export function instanceOfComplexityOSScoreEntry(value: object): value is ComplexityOSScoreEntry {
+    if (!('score' in value) || value['score'] === undefined) return false;
+    if (!('vmCount' in value) || value['vmCount'] === undefined) return false;
+    return true;
+}
+
+export function ComplexityOSScoreEntryFromJSON(json: any): ComplexityOSScoreEntry {
+    return ComplexityOSScoreEntryFromJSONTyped(json, false);
+}
+
+export function ComplexityOSScoreEntryFromJSONTyped(json: any, ignoreDiscriminator: boolean): ComplexityOSScoreEntry {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'score': json['score'],
+        'vmCount': json['vmCount'],
+    };
+}
+
+export function ComplexityOSScoreEntryToJSON(json: any): ComplexityOSScoreEntry {
+    return ComplexityOSScoreEntryToJSONTyped(json, false);
+}
+
+export function ComplexityOSScoreEntryToJSONTyped(value?: ComplexityOSScoreEntry | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'score': value['score'],
+        'vmCount': value['vmCount'],
+    };
+}
+

package/src/models/Info.ts

@@ -31,6 +31,18 @@ export interface Info {
      * @memberof Info
      */
     versionName: string;
+    /**
+     * Agent git commit hash
+     * @type {string}
+     * @memberof Info
+     */
+    agentGitCommit?: string | null;
+    /**
+     * Agent version name, based on git tag
+     * @type {string}
+     * @memberof Info
+     */
+    agentVersionName?: string | null;
 }
 
 /**
@@ -54,6 +66,8 @@ export function InfoFromJSONTyped(json: any, ignoreDiscriminator: boolean): Info
         
         'gitCommit': json['gitCommit'],
         'versionName': json['versionName'],
+        'agentGitCommit': json['agentGitCommit'] == null ? undefined : json['agentGitCommit'],
+        'agentVersionName': json['agentVersionName'] == null ? undefined : json['agentVersionName'],
     };
 }
 
@@ -70,6 +84,8 @@ export function InfoToJSONTyped(value?: Info | null, ignoreDiscriminator: boolea
         
         'gitCommit': value['gitCommit'],
         'versionName': value['versionName'],
+        'agentGitCommit': value['agentGitCommit'],
+        'agentVersionName': value['agentVersionName'],
     };
 }
 

package/src/models/MigrationComplexityRequest.ts

@@ -0,0 +1,66 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * OpenShift Migration Advisor API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: undefined
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { mapValues } from '../runtime.js';
+/**
+ * Request payload for calculating migration complexity estimation
+ * @export
+ * @interface MigrationComplexityRequest
+ */
+export interface MigrationComplexityRequest {
+    /**
+     * ID of the cluster to calculate complexity estimation for
+     * @type {string}
+     * @memberof MigrationComplexityRequest
+     */
+    clusterId: string;
+}
+
+/**
+ * Check if a given object implements the MigrationComplexityRequest interface.
+ */
+export function instanceOfMigrationComplexityRequest(value: object): value is MigrationComplexityRequest {
+    if (!('clusterId' in value) || value['clusterId'] === undefined) return false;
+    return true;
+}
+
+export function MigrationComplexityRequestFromJSON(json: any): MigrationComplexityRequest {
+    return MigrationComplexityRequestFromJSONTyped(json, false);
+}
+
+export function MigrationComplexityRequestFromJSONTyped(json: any, ignoreDiscriminator: boolean): MigrationComplexityRequest {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'clusterId': json['clusterId'],
+    };
+}
+
+export function MigrationComplexityRequestToJSON(json: any): MigrationComplexityRequest {
+    return MigrationComplexityRequestToJSONTyped(json, false);
+}
+
+export function MigrationComplexityRequestToJSONTyped(value?: MigrationComplexityRequest | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'clusterId': value['clusterId'],
+    };
+}
+