@quantcdn/quant-client 2.0.13 → 3.0.1

package/dist/model/models.js

@@ -0,0 +1,370 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VoidAuth = exports.OAuth = exports.ApiKeyAuth = exports.HttpBearerAuth = exports.HttpBasicAuth = exports.ObjectSerializer = void 0;
+__exportStar(require("./application"), exports);
+__exportStar(require("./command"), exports);
+__exportStar(require("./compose"), exports);
+__exportStar(require("./container"), exports);
+__exportStar(require("./containerEnvironmentInner"), exports);
+__exportStar(require("./containerImageReference"), exports);
+__exportStar(require("./containerMountPointsInner"), exports);
+__exportStar(require("./createBackup202Response"), exports);
+__exportStar(require("./createBackupRequest"), exports);
+__exportStar(require("./createCommandRequest"), exports);
+__exportStar(require("./createCronJob422Response"), exports);
+__exportStar(require("./createCronJobRequest"), exports);
+__exportStar(require("./createEnvironmentRequest"), exports);
+__exportStar(require("./cron"), exports);
+__exportStar(require("./cronRun"), exports);
+__exportStar(require("./deleteBackup200Response"), exports);
+__exportStar(require("./downloadBackup200Response"), exports);
+__exportStar(require("./environment"), exports);
+__exportStar(require("./getEcrLoginCredentials200Response"), exports);
+__exportStar(require("./getSshAccessCredentials200Response"), exports);
+__exportStar(require("./getSshAccessCredentials200ResponseCredentials"), exports);
+__exportStar(require("./listBackups200Response"), exports);
+__exportStar(require("./listBackups200ResponseBackupsInner"), exports);
+__exportStar(require("./scalingPolicy"), exports);
+__exportStar(require("./syncOperation"), exports);
+__exportStar(require("./syncToEnvironmentRequest"), exports);
+__exportStar(require("./updateCronJobRequest"), exports);
+__exportStar(require("./updateEnvironmentRequest"), exports);
+__exportStar(require("./updateEnvironmentStateRequest"), exports);
+__exportStar(require("./updateEnvironmentVariableRequest"), exports);
+__exportStar(require("./validateCompose200Response"), exports);
+__exportStar(require("./validateComposeRequest"), exports);
+__exportStar(require("./variable"), exports);
+__exportStar(require("./volume"), exports);
+const application_1 = require("./application");
+const command_1 = require("./command");
+const compose_1 = require("./compose");
+const container_1 = require("./container");
+const containerEnvironmentInner_1 = require("./containerEnvironmentInner");
+const containerImageReference_1 = require("./containerImageReference");
+const containerMountPointsInner_1 = require("./containerMountPointsInner");
+const createBackup202Response_1 = require("./createBackup202Response");
+const createBackupRequest_1 = require("./createBackupRequest");
+const createCommandRequest_1 = require("./createCommandRequest");
+const createCronJob422Response_1 = require("./createCronJob422Response");
+const createCronJobRequest_1 = require("./createCronJobRequest");
+const createEnvironmentRequest_1 = require("./createEnvironmentRequest");
+const cron_1 = require("./cron");
+const cronRun_1 = require("./cronRun");
+const deleteBackup200Response_1 = require("./deleteBackup200Response");
+const downloadBackup200Response_1 = require("./downloadBackup200Response");
+const environment_1 = require("./environment");
+const getEcrLoginCredentials200Response_1 = require("./getEcrLoginCredentials200Response");
+const getSshAccessCredentials200Response_1 = require("./getSshAccessCredentials200Response");
+const getSshAccessCredentials200ResponseCredentials_1 = require("./getSshAccessCredentials200ResponseCredentials");
+const listBackups200Response_1 = require("./listBackups200Response");
+const listBackups200ResponseBackupsInner_1 = require("./listBackups200ResponseBackupsInner");
+const scalingPolicy_1 = require("./scalingPolicy");
+const syncOperation_1 = require("./syncOperation");
+const syncToEnvironmentRequest_1 = require("./syncToEnvironmentRequest");
+const updateCronJobRequest_1 = require("./updateCronJobRequest");
+const updateEnvironmentRequest_1 = require("./updateEnvironmentRequest");
+const updateEnvironmentStateRequest_1 = require("./updateEnvironmentStateRequest");
+const updateEnvironmentVariableRequest_1 = require("./updateEnvironmentVariableRequest");
+const validateCompose200Response_1 = require("./validateCompose200Response");
+const validateComposeRequest_1 = require("./validateComposeRequest");
+const variable_1 = require("./variable");
+const volume_1 = require("./volume");
+/* tslint:disable:no-unused-variable */
+let primitives = [
+    "string",
+    "boolean",
+    "double",
+    "integer",
+    "long",
+    "float",
+    "number",
+    "any"
+];
+let enumsMap = {
+    "CronRun.RunTypeEnum": cronRun_1.CronRun.RunTypeEnum,
+    "CronRun.StatusEnum": cronRun_1.CronRun.StatusEnum,
+    "ScalingPolicy.MetricEnum": scalingPolicy_1.ScalingPolicy.MetricEnum,
+};
+let typeMap = {
+    "Application": application_1.Application,
+    "Command": command_1.Command,
+    "Compose": compose_1.Compose,
+    "Container": container_1.Container,
+    "ContainerEnvironmentInner": containerEnvironmentInner_1.ContainerEnvironmentInner,
+    "ContainerImageReference": containerImageReference_1.ContainerImageReference,
+    "ContainerMountPointsInner": containerMountPointsInner_1.ContainerMountPointsInner,
+    "CreateBackup202Response": createBackup202Response_1.CreateBackup202Response,
+    "CreateBackupRequest": createBackupRequest_1.CreateBackupRequest,
+    "CreateCommandRequest": createCommandRequest_1.CreateCommandRequest,
+    "CreateCronJob422Response": createCronJob422Response_1.CreateCronJob422Response,
+    "CreateCronJobRequest": createCronJobRequest_1.CreateCronJobRequest,
+    "CreateEnvironmentRequest": createEnvironmentRequest_1.CreateEnvironmentRequest,
+    "Cron": cron_1.Cron,
+    "CronRun": cronRun_1.CronRun,
+    "DeleteBackup200Response": deleteBackup200Response_1.DeleteBackup200Response,
+    "DownloadBackup200Response": downloadBackup200Response_1.DownloadBackup200Response,
+    "Environment": environment_1.Environment,
+    "GetEcrLoginCredentials200Response": getEcrLoginCredentials200Response_1.GetEcrLoginCredentials200Response,
+    "GetSshAccessCredentials200Response": getSshAccessCredentials200Response_1.GetSshAccessCredentials200Response,
+    "GetSshAccessCredentials200ResponseCredentials": getSshAccessCredentials200ResponseCredentials_1.GetSshAccessCredentials200ResponseCredentials,
+    "ListBackups200Response": listBackups200Response_1.ListBackups200Response,
+    "ListBackups200ResponseBackupsInner": listBackups200ResponseBackupsInner_1.ListBackups200ResponseBackupsInner,
+    "ScalingPolicy": scalingPolicy_1.ScalingPolicy,
+    "SyncOperation": syncOperation_1.SyncOperation,
+    "SyncToEnvironmentRequest": syncToEnvironmentRequest_1.SyncToEnvironmentRequest,
+    "UpdateCronJobRequest": updateCronJobRequest_1.UpdateCronJobRequest,
+    "UpdateEnvironmentRequest": updateEnvironmentRequest_1.UpdateEnvironmentRequest,
+    "UpdateEnvironmentStateRequest": updateEnvironmentStateRequest_1.UpdateEnvironmentStateRequest,
+    "UpdateEnvironmentVariableRequest": updateEnvironmentVariableRequest_1.UpdateEnvironmentVariableRequest,
+    "ValidateCompose200Response": validateCompose200Response_1.ValidateCompose200Response,
+    "ValidateComposeRequest": validateComposeRequest_1.ValidateComposeRequest,
+    "Variable": variable_1.Variable,
+    "Volume": volume_1.Volume,
+};
+// Check if a string starts with another string without using es6 features
+function startsWith(str, match) {
+    return str.substring(0, match.length) === match;
+}
+// Check if a string ends with another string without using es6 features
+function endsWith(str, match) {
+    return str.length >= match.length && str.substring(str.length - match.length) === match;
+}
+const nullableSuffix = " | null";
+const optionalSuffix = " | undefined";
+const arrayPrefix = "Array<";
+const arraySuffix = ">";
+const mapPrefix = "{ [key: string]: ";
+const mapSuffix = "; }";
+class ObjectSerializer {
+    static findCorrectType(data, expectedType) {
+        if (data == undefined) {
+            return expectedType;
+        }
+        else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
+            return expectedType;
+        }
+        else if (expectedType === "Date") {
+            return expectedType;
+        }
+        else {
+            if (enumsMap[expectedType]) {
+                return expectedType;
+            }
+            if (!typeMap[expectedType]) {
+                return expectedType; // w/e we don't know the type
+            }
+            // Check the discriminator
+            let discriminatorProperty = typeMap[expectedType].discriminator;
+            if (discriminatorProperty == null) {
+                return expectedType; // the type does not have a discriminator. use it.
+            }
+            else {
+                if (data[discriminatorProperty]) {
+                    var discriminatorType = data[discriminatorProperty];
+                    if (typeMap[discriminatorType]) {
+                        return discriminatorType; // use the type given in the discriminator
+                    }
+                    else {
+                        return expectedType; // discriminator did not map to a type
+                    }
+                }
+                else {
+                    return expectedType; // discriminator was not present (or an empty string)
+                }
+            }
+        }
+    }
+    static serialize(data, type) {
+        if (data == undefined) {
+            return data;
+        }
+        else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        }
+        else if (endsWith(type, nullableSuffix)) {
+            let subType = type.slice(0, -nullableSuffix.length); // Type | null => Type
+            return ObjectSerializer.serialize(data, subType);
+        }
+        else if (endsWith(type, optionalSuffix)) {
+            let subType = type.slice(0, -optionalSuffix.length); // Type | undefined => Type
+            return ObjectSerializer.serialize(data, subType);
+        }
+        else if (startsWith(type, arrayPrefix)) {
+            let subType = type.slice(arrayPrefix.length, -arraySuffix.length); // Array<Type> => Type
+            let transformedData = [];
+            for (let index = 0; index < data.length; index++) {
+                let datum = data[index];
+                transformedData.push(ObjectSerializer.serialize(datum, subType));
+            }
+            return transformedData;
+        }
+        else if (startsWith(type, mapPrefix)) {
+            let subType = type.slice(mapPrefix.length, -mapSuffix.length); // { [key: string]: Type; } => Type
+            let transformedData = {};
+            for (let key in data) {
+                transformedData[key] = ObjectSerializer.serialize(data[key], subType);
+            }
+            return transformedData;
+        }
+        else if (type === "Date") {
+            return data.toISOString();
+        }
+        else {
+            if (enumsMap[type]) {
+                return data;
+            }
+            if (!typeMap[type]) { // in case we dont know the type
+                return data;
+            }
+            // Get the actual type of this object
+            type = this.findCorrectType(data, type);
+            // get the map for the correct type.
+            let attributeTypes = typeMap[type].getAttributeTypeMap();
+            let instance = {};
+            for (let index = 0; index < attributeTypes.length; index++) {
+                let attributeType = attributeTypes[index];
+                instance[attributeType.baseName] = ObjectSerializer.serialize(data[attributeType.name], attributeType.type);
+            }
+            return instance;
+        }
+    }
+    static deserialize(data, type) {
+        // polymorphism may change the actual type.
+        type = ObjectSerializer.findCorrectType(data, type);
+        if (data == undefined) {
+            return data;
+        }
+        else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        }
+        else if (endsWith(type, nullableSuffix)) {
+            let subType = type.slice(0, -nullableSuffix.length); // Type | null => Type
+            return ObjectSerializer.deserialize(data, subType);
+        }
+        else if (endsWith(type, optionalSuffix)) {
+            let subType = type.slice(0, -optionalSuffix.length); // Type | undefined => Type
+            return ObjectSerializer.deserialize(data, subType);
+        }
+        else if (startsWith(type, arrayPrefix)) {
+            let subType = type.slice(arrayPrefix.length, -arraySuffix.length); // Array<Type> => Type
+            let transformedData = [];
+            for (let index = 0; index < data.length; index++) {
+                let datum = data[index];
+                transformedData.push(ObjectSerializer.deserialize(datum, subType));
+            }
+            return transformedData;
+        }
+        else if (startsWith(type, mapPrefix)) {
+            let subType = type.slice(mapPrefix.length, -mapSuffix.length); // { [key: string]: Type; } => Type
+            let transformedData = {};
+            for (let key in data) {
+                transformedData[key] = ObjectSerializer.deserialize(data[key], subType);
+            }
+            return transformedData;
+        }
+        else if (type === "Date") {
+            return new Date(data);
+        }
+        else {
+            if (enumsMap[type]) { // is Enum
+                return data;
+            }
+            if (!typeMap[type]) { // dont know the type
+                return data;
+            }
+            let instance = new typeMap[type]();
+            let attributeTypes = typeMap[type].getAttributeTypeMap();
+            for (let index = 0; index < attributeTypes.length; index++) {
+                let attributeType = attributeTypes[index];
+                instance[attributeType.name] = ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type);
+            }
+            return instance;
+        }
+    }
+}
+exports.ObjectSerializer = ObjectSerializer;
+class HttpBasicAuth {
+    constructor() {
+        this.username = '';
+        this.password = '';
+    }
+    applyToRequest(requestOptions) {
+        requestOptions.auth = {
+            username: this.username, password: this.password
+        };
+    }
+}
+exports.HttpBasicAuth = HttpBasicAuth;
+class HttpBearerAuth {
+    constructor() {
+        this.accessToken = '';
+    }
+    applyToRequest(requestOptions) {
+        if (requestOptions && requestOptions.headers) {
+            const accessToken = typeof this.accessToken === 'function'
+                ? this.accessToken()
+                : this.accessToken;
+            requestOptions.headers["Authorization"] = "Bearer " + accessToken;
+        }
+    }
+}
+exports.HttpBearerAuth = HttpBearerAuth;
+class ApiKeyAuth {
+    constructor(location, paramName) {
+        this.location = location;
+        this.paramName = paramName;
+        this.apiKey = '';
+    }
+    applyToRequest(requestOptions) {
+        if (this.location == "query") {
+            requestOptions.qs[this.paramName] = this.apiKey;
+        }
+        else if (this.location == "header" && requestOptions && requestOptions.headers) {
+            requestOptions.headers[this.paramName] = this.apiKey;
+        }
+        else if (this.location == 'cookie' && requestOptions && requestOptions.headers) {
+            if (requestOptions.headers['Cookie']) {
+                requestOptions.headers['Cookie'] += '; ' + this.paramName + '=' + encodeURIComponent(this.apiKey);
+            }
+            else {
+                requestOptions.headers['Cookie'] = this.paramName + '=' + encodeURIComponent(this.apiKey);
+            }
+        }
+    }
+}
+exports.ApiKeyAuth = ApiKeyAuth;
+class OAuth {
+    constructor() {
+        this.accessToken = '';
+    }
+    applyToRequest(requestOptions) {
+        if (requestOptions && requestOptions.headers) {
+            requestOptions.headers["Authorization"] = "Bearer " + this.accessToken;
+        }
+    }
+}
+exports.OAuth = OAuth;
+class VoidAuth {
+    constructor() {
+        this.username = '';
+        this.password = '';
+    }
+    applyToRequest(_) {
+        // Do nothing
+    }
+}
+exports.VoidAuth = VoidAuth;

package/dist/model/scalingPolicy.d.ts

@@ -0,0 +1,35 @@
+/**
+ * QuantCloud API
+ * QuantCloud API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export declare class ScalingPolicy {
+    'metric'?: ScalingPolicy.MetricEnum;
+    'targetValue'?: number;
+    'scaleInCooldownSeconds'?: number;
+    'scaleOutCooldownSeconds'?: number;
+    static discriminator: string | undefined;
+    static attributeTypeMap: Array<{
+        name: string;
+        baseName: string;
+        type: string;
+    }>;
+    static getAttributeTypeMap(): {
+        name: string;
+        baseName: string;
+        type: string;
+    }[];
+}
+export declare namespace ScalingPolicy {
+    enum MetricEnum {
+        CpuUtilization,
+        MemoryUtilization,
+        Rps
+    }
+}

package/dist/model/scalingPolicy.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * QuantCloud API
+ * QuantCloud API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalingPolicy = void 0;
+class ScalingPolicy {
+    static getAttributeTypeMap() {
+        return ScalingPolicy.attributeTypeMap;
+    }
+}
+exports.ScalingPolicy = ScalingPolicy;
+ScalingPolicy.discriminator = undefined;
+ScalingPolicy.attributeTypeMap = [
+    {
+        "name": "metric",
+        "baseName": "metric",
+        "type": "ScalingPolicy.MetricEnum"
+    },
+    {
+        "name": "targetValue",
+        "baseName": "targetValue",
+        "type": "number"
+    },
+    {
+        "name": "scaleInCooldownSeconds",
+        "baseName": "scaleInCooldownSeconds",
+        "type": "number"
+    },
+    {
+        "name": "scaleOutCooldownSeconds",
+        "baseName": "scaleOutCooldownSeconds",
+        "type": "number"
+    }
+];
+(function (ScalingPolicy) {
+    let MetricEnum;
+    (function (MetricEnum) {
+        MetricEnum[MetricEnum["CpuUtilization"] = 'CPUUtilization'] = "CpuUtilization";
+        MetricEnum[MetricEnum["MemoryUtilization"] = 'MemoryUtilization'] = "MemoryUtilization";
+        MetricEnum[MetricEnum["Rps"] = 'RPS'] = "Rps";
+    })(MetricEnum = ScalingPolicy.MetricEnum || (ScalingPolicy.MetricEnum = {}));
+})(ScalingPolicy = exports.ScalingPolicy || (exports.ScalingPolicy = {}));

package/dist/model/syncOperation.d.ts

@@ -0,0 +1,31 @@
+/**
+ * QuantCloud API
+ * QuantCloud API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export declare class SyncOperation {
+    'syncId'?: string;
+    'syncType'?: string;
+    'sourceEnvironment'?: string;
+    'targetEnvironment'?: string;
+    'status'?: string;
+    'createdAt'?: string;
+    'completedAt'?: string;
+    static discriminator: string | undefined;
+    static attributeTypeMap: Array<{
+        name: string;
+        baseName: string;
+        type: string;
+    }>;
+    static getAttributeTypeMap(): {
+        name: string;
+        baseName: string;
+        type: string;
+    }[];
+}

package/dist/model/syncOperation.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * QuantCloud API
+ * QuantCloud API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncOperation = void 0;
+class SyncOperation {
+    static getAttributeTypeMap() {
+        return SyncOperation.attributeTypeMap;
+    }
+}
+exports.SyncOperation = SyncOperation;
+SyncOperation.discriminator = undefined;
+SyncOperation.attributeTypeMap = [
+    {
+        "name": "syncId",
+        "baseName": "syncId",
+        "type": "string"
+    },
+    {
+        "name": "syncType",
+        "baseName": "syncType",
+        "type": "string"
+    },
+    {
+        "name": "sourceEnvironment",
+        "baseName": "sourceEnvironment",
+        "type": "string"
+    },
+    {
+        "name": "targetEnvironment",
+        "baseName": "targetEnvironment",
+        "type": "string"
+    },
+    {
+        "name": "status",
+        "baseName": "status",
+        "type": "string"
+    },
+    {
+        "name": "createdAt",
+        "baseName": "createdAt",
+        "type": "string"
+    },
+    {
+        "name": "completedAt",
+        "baseName": "completedAt",
+        "type": "string"
+    }
+];

package/dist/model/syncToEnvironmentRequest.d.ts

@@ -0,0 +1,25 @@
+/**
+ * QuantCloud API
+ * QuantCloud API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+export declare class SyncToEnvironmentRequest {
+    'sourceEnvironment'?: string;
+    static discriminator: string | undefined;
+    static attributeTypeMap: Array<{
+        name: string;
+        baseName: string;
+        type: string;
+    }>;
+    static getAttributeTypeMap(): {
+        name: string;
+        baseName: string;
+        type: string;
+    }[];
+}

package/dist/model/syncToEnvironmentRequest.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * QuantCloud API
+ * QuantCloud API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncToEnvironmentRequest = void 0;
+class SyncToEnvironmentRequest {
+    static getAttributeTypeMap() {
+        return SyncToEnvironmentRequest.attributeTypeMap;
+    }
+}
+exports.SyncToEnvironmentRequest = SyncToEnvironmentRequest;
+SyncToEnvironmentRequest.discriminator = undefined;
+SyncToEnvironmentRequest.attributeTypeMap = [
+    {
+        "name": "sourceEnvironment",
+        "baseName": "sourceEnvironment",
+        "type": "string"
+    }
+];

package/dist/model/updateComposeRequest.d.ts

@@ -0,0 +1,26 @@
+/**
+ * QuantCloud API
+ * QuantCloud API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import { Compose } from './compose';
+export declare class UpdateComposeRequest {
+    'composeDefinition'?: Compose;
+    static discriminator: string | undefined;
+    static attributeTypeMap: Array<{
+        name: string;
+        baseName: string;
+        type: string;
+    }>;
+    static getAttributeTypeMap(): {
+        name: string;
+        baseName: string;
+        type: string;
+    }[];
+}

package/dist/model/updateComposeRequest.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * QuantCloud API
+ * QuantCloud API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpdateComposeRequest = void 0;
+class UpdateComposeRequest {
+    static getAttributeTypeMap() {
+        return UpdateComposeRequest.attributeTypeMap;
+    }
+}
+exports.UpdateComposeRequest = UpdateComposeRequest;
+UpdateComposeRequest.discriminator = undefined;
+UpdateComposeRequest.attributeTypeMap = [
+    {
+        "name": "composeDefinition",
+        "baseName": "composeDefinition",
+        "type": "Compose"
+    }
+];