@openshift-migration-advisor/planner-sdk 0.8.0-c0804255c486 → 0.9.0-a26ff9932eeb

package/docs/OsDiskEstimationEntry.md

@@ -0,0 +1,40 @@
+
+# OsDiskEstimationEntry
+
+
+## Properties
+
+Name | Type
+------------ | -------------
+`score` | number
+`vmCount` | number
+`totalDiskSizeTB` | number
+`estimation` | [{ [key: string]: SchemaEstimationResult; }](SchemaEstimationResult.md)
+
+## Example
+
+```typescript
+import type { OsDiskEstimationEntry } from '@openshift-migration-advisor/planner-sdk'
+
+// TODO: Update the object below with actual values
+const example = {
+  "score": null,
+  "vmCount": null,
+  "totalDiskSizeTB": null,
+  "estimation": null,
+} satisfies OsDiskEstimationEntry
+
+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 OsDiskEstimationEntry
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openshift-migration-advisor/planner-sdk",
-  "version": "0.8.0-c0804255c486",
+  "version": "0.9.0-a26ff9932eeb",
   "description": "OpenAPI client for @openshift-migration-advisor/planner-sdk",
   "author": "OpenAPI-Generator",
   "repository": {

package/src/apis/AssessmentApi.ts

@@ -22,6 +22,7 @@ import type {
   ClusterRequirementsResponse,
   MigrationComplexityRequest,
   MigrationComplexityResponse,
+  MigrationEstimationByComplexityResponse,
   MigrationEstimationRequest,
   SchemaEstimationResult,
 } from '../models/index.js';
@@ -40,6 +41,8 @@ import {
     MigrationComplexityRequestToJSON,
     MigrationComplexityResponseFromJSON,
     MigrationComplexityResponseToJSON,
+    MigrationEstimationByComplexityResponseFromJSON,
+    MigrationEstimationByComplexityResponseToJSON,
     MigrationEstimationRequestFromJSON,
     MigrationEstimationRequestToJSON,
     SchemaEstimationResultFromJSON,
@@ -61,6 +64,11 @@ export interface CalculateMigrationEstimationRequest {
     migrationEstimationRequest: MigrationEstimationRequest;
 }
 
+export interface CalculateMigrationEstimationByComplexityRequest {
+    id: string;
+    migrationEstimationRequest: MigrationEstimationRequest;
+}
+
 export interface CreateAssessmentRequest {
     assessmentForm: AssessmentForm;
 }
@@ -161,6 +169,30 @@ export interface AssessmentApiInterface {
      */
     calculateMigrationEstimation(requestParameters: CalculateMigrationEstimationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: SchemaEstimationResult; }>;
 
+    /**
+     * Creates request options for calculateMigrationEstimationByComplexity without sending the request
+     * @param {string} id ID of the assessment
+     * @param {MigrationEstimationRequest} migrationEstimationRequest 
+     * @throws {RequiredError}
+     * @memberof AssessmentApiInterface
+     */
+    calculateMigrationEstimationByComplexityRequestOpts(requestParameters: CalculateMigrationEstimationByComplexityRequest): Promise<runtime.RequestOpts>;
+
+    /**
+     * Calculate migration time estimation broken down by combined OS+Disk complexity
+     * @param {string} id ID of the assessment
+     * @param {MigrationEstimationRequest} migrationEstimationRequest 
+     * @param {*} [options] Override http request option.
+     * @throws {RequiredError}
+     * @memberof AssessmentApiInterface
+     */
+    calculateMigrationEstimationByComplexityRaw(requestParameters: CalculateMigrationEstimationByComplexityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MigrationEstimationByComplexityResponse>>;
+
+    /**
+     * Calculate migration time estimation broken down by combined OS+Disk complexity
+     */
+    calculateMigrationEstimationByComplexity(requestParameters: CalculateMigrationEstimationByComplexityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MigrationEstimationByComplexityResponse>;
+
     /**
      * Creates request options for createAssessment without sending the request
      * @param {AssessmentForm} assessmentForm 
@@ -445,6 +477,61 @@ export class AssessmentApi extends runtime.BaseAPI implements AssessmentApiInter
         return await response.value();
     }
 
+    /**
+     * Creates request options for calculateMigrationEstimationByComplexity without sending the request
+     */
+    async calculateMigrationEstimationByComplexityRequestOpts(requestParameters: CalculateMigrationEstimationByComplexityRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError(
+                'id',
+                'Required parameter "id" was null or undefined when calling calculateMigrationEstimationByComplexity().'
+            );
+        }
+
+        if (requestParameters['migrationEstimationRequest'] == null) {
+            throw new runtime.RequiredError(
+                'migrationEstimationRequest',
+                'Required parameter "migrationEstimationRequest" was null or undefined when calling calculateMigrationEstimationByComplexity().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/api/v1/assessments/{id}/migration-estimation/by-complexity`;
+        urlPath = urlPath.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: MigrationEstimationRequestToJSON(requestParameters['migrationEstimationRequest']),
+        };
+    }
+
+    /**
+     * Calculate migration time estimation broken down by combined OS+Disk complexity
+     */
+    async calculateMigrationEstimationByComplexityRaw(requestParameters: CalculateMigrationEstimationByComplexityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<MigrationEstimationByComplexityResponse>> {
+        const requestOptions = await this.calculateMigrationEstimationByComplexityRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => MigrationEstimationByComplexityResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Calculate migration time estimation broken down by combined OS+Disk complexity
+     */
+    async calculateMigrationEstimationByComplexity(requestParameters: CalculateMigrationEstimationByComplexityRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<MigrationEstimationByComplexityResponse> {
+        const response = await this.calculateMigrationEstimationByComplexityRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for createAssessment without sending the request
      */

package/src/models/ComplexityOSNameEntry.ts

@@ -27,7 +27,7 @@ export interface ComplexityOSNameEntry {
      */
     osName: string;
     /**
-     * Complexity score assigned by ClassifyOS. 0 = unclassified, 1 = least complex, 4 = most complex.
+     * Complexity score assigned by ClassifyOS. 0 = unknown, 1 = least complex, 4 = most complex.
      * 
      * @type {number}
      * @memberof ComplexityOSNameEntry

package/src/models/ComplexityOSScoreEntry.ts

@@ -20,7 +20,7 @@ import { mapValues } from '../runtime.js';
  */
 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.
+     * Complexity score from 0 to 4, where 1 indicates the least complex OS to migrate and 0 indicates an OS with unknown complexity.
      * 
      * @type {number}
      * @memberof ComplexityOSScoreEntry

package/src/models/EstimationContext.ts

@@ -0,0 +1,73 @@
+/* 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';
+/**
+ * 
+ * @export
+ * @interface EstimationContext
+ */
+export interface EstimationContext {
+    /**
+     * 
+     * @type {Array<string>}
+     * @memberof EstimationContext
+     */
+    schemas?: Array<string>;
+    /**
+     * 
+     * @type {{ [key: string]: number; }}
+     * @memberof EstimationContext
+     */
+    params?: { [key: string]: number; };
+}
+
+/**
+ * Check if a given object implements the EstimationContext interface.
+ */
+export function instanceOfEstimationContext(value: object): value is EstimationContext {
+    return true;
+}
+
+export function EstimationContextFromJSON(json: any): EstimationContext {
+    return EstimationContextFromJSONTyped(json, false);
+}
+
+export function EstimationContextFromJSONTyped(json: any, ignoreDiscriminator: boolean): EstimationContext {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'schemas': json['schemas'] == null ? undefined : json['schemas'],
+        'params': json['params'] == null ? undefined : json['params'],
+    };
+}
+
+export function EstimationContextToJSON(json: any): EstimationContext {
+    return EstimationContextToJSONTyped(json, false);
+}
+
+export function EstimationContextToJSONTyped(value?: EstimationContext | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'schemas': value['schemas'],
+        'params': value['params'],
+    };
+}
+

package/src/models/MigrationComplexityResponse.ts

@@ -49,7 +49,7 @@ export interface MigrationComplexityResponse {
      */
     complexityByDisk: Array<ComplexityDiskScoreEntry>;
     /**
-     * OS complexity scores, one entry per score level (0-4). Score 1 indicates the least complex OS to migrate; score 0 indicates an OS that could not be classified. All five score levels are always present.
+     * OS complexity scores, one entry per score level (0-4). Score 1 indicates the least complex OS to migrate; score 0 indicates an OS with unknown complexity. All five score levels are always present.
      * 
      * @type {Array<ComplexityOSScoreEntry>}
      * @memberof MigrationComplexityResponse
@@ -63,7 +63,7 @@ export interface MigrationComplexityResponse {
      */
     diskSizeRatings: { [key: string]: number; };
     /**
-     * Per-OS-name score for every OS found in this cluster's inventory. Keys are the OS name strings exactly as they appear in vms.osInfo; values are the numeric complexity score assigned by ClassifyOS (0 = unclassified, 1-4 = increasing complexity). The map contains one entry per distinct OS name in the cluster, regardless of how many VMs run it.
+     * Per-OS-name score for every OS found in this cluster's inventory. Keys are the OS name strings exactly as they appear in vms.osInfo; values are the numeric complexity score assigned by ClassifyOS (0 = unknown, 1-4 = increasing complexity). The map contains one entry per distinct OS name in the cluster, regardless of how many VMs run it.
      * 
      * @type {{ [key: string]: number; }}
      * @memberof MigrationComplexityResponse

package/src/models/MigrationEstimationByComplexityResponse.ts

@@ -0,0 +1,98 @@
+/* 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';
+import type { OsDiskEstimationEntry } from './OsDiskEstimationEntry.js';
+import {
+    OsDiskEstimationEntryFromJSON,
+    OsDiskEstimationEntryFromJSONTyped,
+    OsDiskEstimationEntryToJSON,
+    OsDiskEstimationEntryToJSONTyped,
+} from './OsDiskEstimationEntry.js';
+import type { EstimationContext } from './EstimationContext.js';
+import {
+    EstimationContextFromJSON,
+    EstimationContextFromJSONTyped,
+    EstimationContextToJSON,
+    EstimationContextToJSONTyped,
+} from './EstimationContext.js';
+
+/**
+ * 
+ * @export
+ * @interface MigrationEstimationByComplexityResponse
+ */
+export interface MigrationEstimationByComplexityResponse {
+    /**
+     * Combined OS+Disk complexity distribution with per-bucket estimation. All 5 score levels (0-4) always present.
+     * @type {Array<OsDiskEstimationEntry>}
+     * @memberof MigrationEstimationByComplexityResponse
+     */
+    complexityByOsDisk: Array<OsDiskEstimationEntry>;
+    /**
+     * Decision matrix: outer keys are OS scores (0-4), inner keys are disk scores (1-4), values are combined scores.
+     * @type {{ [key: string]: { [key: string]: number; }; }}
+     * @memberof MigrationEstimationByComplexityResponse
+     */
+    complexityMatrix: { [key: string]: { [key: string]: number; }; };
+    /**
+     * 
+     * @type {EstimationContext}
+     * @memberof MigrationEstimationByComplexityResponse
+     */
+    estimationContext?: EstimationContext;
+}
+
+/**
+ * Check if a given object implements the MigrationEstimationByComplexityResponse interface.
+ */
+export function instanceOfMigrationEstimationByComplexityResponse(value: object): value is MigrationEstimationByComplexityResponse {
+    if (!('complexityByOsDisk' in value) || value['complexityByOsDisk'] === undefined) return false;
+    if (!('complexityMatrix' in value) || value['complexityMatrix'] === undefined) return false;
+    return true;
+}
+
+export function MigrationEstimationByComplexityResponseFromJSON(json: any): MigrationEstimationByComplexityResponse {
+    return MigrationEstimationByComplexityResponseFromJSONTyped(json, false);
+}
+
+export function MigrationEstimationByComplexityResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): MigrationEstimationByComplexityResponse {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'complexityByOsDisk': ((json['complexityByOsDisk'] as Array<any>).map(OsDiskEstimationEntryFromJSON)),
+        'complexityMatrix': json['complexityMatrix'],
+        'estimationContext': json['estimationContext'] == null ? undefined : EstimationContextFromJSON(json['estimationContext']),
+    };
+}
+
+export function MigrationEstimationByComplexityResponseToJSON(json: any): MigrationEstimationByComplexityResponse {
+    return MigrationEstimationByComplexityResponseToJSONTyped(json, false);
+}
+
+export function MigrationEstimationByComplexityResponseToJSONTyped(value?: MigrationEstimationByComplexityResponse | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'complexityByOsDisk': ((value['complexityByOsDisk'] as Array<any>).map(OsDiskEstimationEntryToJSON)),
+        'complexityMatrix': value['complexityMatrix'],
+        'estimationContext': EstimationContextToJSON(value['estimationContext']),
+    };
+}
+

package/src/models/OsDiskEstimationEntry.ts

@@ -0,0 +1,100 @@
+/* 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';
+import type { SchemaEstimationResult } from './SchemaEstimationResult.js';
+import {
+    SchemaEstimationResultFromJSON,
+    SchemaEstimationResultFromJSONTyped,
+    SchemaEstimationResultToJSON,
+    SchemaEstimationResultToJSONTyped,
+} from './SchemaEstimationResult.js';
+
+/**
+ * 
+ * @export
+ * @interface OsDiskEstimationEntry
+ */
+export interface OsDiskEstimationEntry {
+    /**
+     * Combined OS+Disk complexity score (0-4).
+     * @type {number}
+     * @memberof OsDiskEstimationEntry
+     */
+    score: number;
+    /**
+     * Number of VMs at this complexity level.
+     * @type {number}
+     * @memberof OsDiskEstimationEntry
+     */
+    vmCount: number;
+    /**
+     * Total provisioned disk across VMs in this bucket (decimal TB). 0.0 when ComplexityDistribution is absent from the inventory.
+     * @type {number}
+     * @memberof OsDiskEstimationEntry
+     */
+    totalDiskSizeTB: number;
+    /**
+     * Full estimation breakdown keyed by schema name. Absent for empty buckets (vmCount == 0).
+     * @type {{ [key: string]: SchemaEstimationResult; }}
+     * @memberof OsDiskEstimationEntry
+     */
+    estimation?: { [key: string]: SchemaEstimationResult; };
+}
+
+/**
+ * Check if a given object implements the OsDiskEstimationEntry interface.
+ */
+export function instanceOfOsDiskEstimationEntry(value: object): value is OsDiskEstimationEntry {
+    if (!('score' in value) || value['score'] === undefined) return false;
+    if (!('vmCount' in value) || value['vmCount'] === undefined) return false;
+    if (!('totalDiskSizeTB' in value) || value['totalDiskSizeTB'] === undefined) return false;
+    return true;
+}
+
+export function OsDiskEstimationEntryFromJSON(json: any): OsDiskEstimationEntry {
+    return OsDiskEstimationEntryFromJSONTyped(json, false);
+}
+
+export function OsDiskEstimationEntryFromJSONTyped(json: any, ignoreDiscriminator: boolean): OsDiskEstimationEntry {
+    if (json == null) {
+        return json;
+    }
+    return {
+        
+        'score': json['score'],
+        'vmCount': json['vmCount'],
+        'totalDiskSizeTB': json['totalDiskSizeTB'],
+        'estimation': json['estimation'] == null ? undefined : (mapValues(json['estimation'], SchemaEstimationResultFromJSON)),
+    };
+}
+
+export function OsDiskEstimationEntryToJSON(json: any): OsDiskEstimationEntry {
+    return OsDiskEstimationEntryToJSONTyped(json, false);
+}
+
+export function OsDiskEstimationEntryToJSONTyped(value?: OsDiskEstimationEntry | null, ignoreDiscriminator: boolean = false): any {
+    if (value == null) {
+        return value;
+    }
+
+    return {
+        
+        'score': value['score'],
+        'vmCount': value['vmCount'],
+        'totalDiskSizeTB': value['totalDiskSizeTB'],
+        'estimation': value['estimation'] == null ? undefined : (mapValues(value['estimation'], SchemaEstimationResultToJSON)),
+    };
+}
+

package/src/models/index.ts

@@ -14,6 +14,7 @@ export * from './ComplexityOSScoreEntry.js';
 export * from './Datastore.js';
 export * from './DiskSizeTierSummary.js';
 export * from './DiskTypeSummary.js';
+export * from './EstimationContext.js';
 export * from './EstimationDetail.js';
 export * from './Histogram.js';
 export * from './Host.js';
@@ -28,10 +29,12 @@ export * from './JobStatus.js';
 export * from './Label.js';
 export * from './MigrationComplexityRequest.js';
 export * from './MigrationComplexityResponse.js';
+export * from './MigrationEstimationByComplexityResponse.js';
 export * from './MigrationEstimationRequest.js';
 export * from './MigrationIssue.js';
 export * from './ModelError.js';
 export * from './Network.js';
+export * from './OsDiskEstimationEntry.js';
 export * from './OsInfo.js';
 export * from './PresignedUrl.js';
 export * from './SchemaEstimationResult.js';