@product-live/api-sdk 2.5.1 → 2.10.0

package/models/LowOrderQuery.ts

@@ -1,10 +1,8 @@
-/* tslint:disable */
-/* eslint-disable */
 /**
  * Product-Live API
  * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
  *
- * The version of the OpenAPI document: 2.5.1
+ * OpenAPI spec version: 2.8.1
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -12,104 +10,51 @@
  * Do not edit the class manually.
  */
 
-import { exists, mapValues } from '../runtime';
-import type { Any } from './Any';
-import {
-    AnyFromJSON,
-    AnyFromJSONTyped,
-    AnyToJSON,
-} from './Any';
-
-/**
- * 
- * @export
- * @interface LowOrderQuery
- */
-export interface LowOrderQuery {
-    /**
-     * 
-     * @type {Any}
-     * @memberof LowOrderQuery
-     */
-    value?: Any;
-    /**
-     * 
-     * @type {string}
-     * @memberof LowOrderQuery
-     */
-    field?: string;
-    /**
-     * 
-     * @type {boolean}
-     * @memberof LowOrderQuery
-     */
-    caseSensitive?: boolean;
-    /**
-     * 
-     * @type {string}
-     * @memberof LowOrderQuery
-     */
-    type?: LowOrderQueryTypeEnum;
-}
-
-
-/**
- * @export
- */
-export const LowOrderQueryTypeEnum = {
-    Eq: 'eq',
-    Eq: 'eq',
-    Search: 'search',
-    In: 'in',
-    True: 'true',
-    False: 'false',
-    Greater: 'greater',
-    GreaterOrEqual: 'greaterOrEqual',
-    Lower: 'lower',
-    LowerOrEqual: 'lowerOrEqual'
-} as const;
-export type LowOrderQueryTypeEnum = typeof LowOrderQueryTypeEnum[keyof typeof LowOrderQueryTypeEnum];
-
-
-/**
- * Check if a given object implements the LowOrderQuery interface.
- */
-export function instanceOfLowOrderQuery(value: object): boolean {
-    let isInstance = true;
-
-    return isInstance;
-}
-
-export function LowOrderQueryFromJSON(json: any): LowOrderQuery {
-    return LowOrderQueryFromJSONTyped(json, false);
-}
-
-export function LowOrderQueryFromJSONTyped(json: any, ignoreDiscriminator: boolean): LowOrderQuery {
-    if ((json === undefined) || (json === null)) {
-        return json;
+import { LowOrderQueryValue } from '../models/LowOrderQueryValue';
+import { HttpFile } from '../http/http';
+
+export class LowOrderQuery {
+    'value'?: LowOrderQueryValue;
+    'field'?: string;
+    'caseSensitive'?: boolean;
+    'type'?: LowOrderQueryTypeEnum;
+
+    static readonly discriminator: string | undefined = undefined;
+
+    static readonly attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string}> = [
+        {
+            "name": "value",
+            "baseName": "value",
+            "type": "LowOrderQueryValue",
+            "format": ""
+        },
+        {
+            "name": "field",
+            "baseName": "field",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "caseSensitive",
+            "baseName": "caseSensitive",
+            "type": "boolean",
+            "format": ""
+        },
+        {
+            "name": "type",
+            "baseName": "type",
+            "type": "LowOrderQueryTypeEnum",
+            "format": ""
+        }    ];
+
+    static getAttributeTypeMap() {
+        return LowOrderQuery.attributeTypeMap;
     }
-    return {
-        
-        'value': !exists(json, 'value') ? undefined : AnyFromJSON(json['value']),
-        'field': !exists(json, 'field') ? undefined : json['field'],
-        'caseSensitive': !exists(json, 'caseSensitive') ? undefined : json['caseSensitive'],
-        'type': !exists(json, 'type') ? undefined : json['type'],
-    };
-}
 
-export function LowOrderQueryToJSON(value?: LowOrderQuery | null): any {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (value === null) {
-        return null;
+    public constructor() {
     }
-    return {
-        
-        'value': AnyToJSON(value.value),
-        'field': value.field,
-        'caseSensitive': value.caseSensitive,
-        'type': value.type,
-    };
 }
 
+
+export type LowOrderQueryTypeEnum = "eq" | "eq" | "search" | "in" | "true" | "false" | "greater" | "greaterOrEqual" | "lower" | "lowerOrEqual" ;
+

package/models/LowOrderQueryValue.ts

@@ -0,0 +1,29 @@
+/**
+ * Product-Live API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * OpenAPI spec version: 2.8.1
+ * 
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+
+import { HttpFile } from '../http/http';
+
+export class LowOrderQueryValue {
+
+    static readonly discriminator: string | undefined = undefined;
+
+    static readonly attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string}> = [
+    ];
+
+    static getAttributeTypeMap() {
+        return LowOrderQueryValue.attributeTypeMap;
+    }
+
+    public constructor() {
+    }
+}
+

package/models/ObjectSerializer.ts

@@ -0,0 +1,324 @@
+export * from '../models/CreateJobDto';
+export * from '../models/CreateJobExecutionDto';
+export * from '../models/CreateTaskDto';
+export * from '../models/CreateVariableDto';
+export * from '../models/FileDto';
+export * from '../models/FindVariablesRequest';
+export * from '../models/GetFiles200Response';
+export * from '../models/GetJobExecutionById400Response';
+export * from '../models/GetJobExecutions200Response';
+export * from '../models/GetJobs200Response';
+export * from '../models/GetTasks200Response';
+export * from '../models/GetVariables200Response';
+export * from '../models/HighOrderQuery';
+export * from '../models/JobDto';
+export * from '../models/JobExecutionDto';
+export * from '../models/LowOrderQuery';
+export * from '../models/LowOrderQueryValue';
+export * from '../models/PatchTaskExecutionDto';
+export * from '../models/Query';
+export * from '../models/TaskDto';
+export * from '../models/TaskExecutionDto';
+export * from '../models/UpdateJobDto';
+export * from '../models/UpdateTaskDto';
+export * from '../models/UpdateVariableDto';
+export * from '../models/VariableDto';
+
+import { CreateJobDto    , CreateJobDtoStatusEnum         } from '../models/CreateJobDto';
+import { CreateJobExecutionDto } from '../models/CreateJobExecutionDto';
+import { CreateTaskDto } from '../models/CreateTaskDto';
+import { CreateVariableDto  , CreateVariableDtoStatusEnum     } from '../models/CreateVariableDto';
+import { FileDto, FileDtoObjectEnum        } from '../models/FileDto';
+import { FindVariablesRequest, FindVariablesRequestTypeEnum       } from '../models/FindVariablesRequest';
+import { GetFiles200Response, GetFiles200ResponseObjectEnum     } from '../models/GetFiles200Response';
+import { GetJobExecutionById400Response } from '../models/GetJobExecutionById400Response';
+import { GetJobExecutions200Response, GetJobExecutions200ResponseObjectEnum     } from '../models/GetJobExecutions200Response';
+import { GetJobs200Response, GetJobs200ResponseObjectEnum     } from '../models/GetJobs200Response';
+import { GetTasks200Response, GetTasks200ResponseObjectEnum     } from '../models/GetTasks200Response';
+import { GetVariables200Response, GetVariables200ResponseObjectEnum     } from '../models/GetVariables200Response';
+import { HighOrderQuery , HighOrderQueryTypeEnum   } from '../models/HighOrderQuery';
+import { JobDto    , JobDtoStatusEnum         , JobDtoObjectEnum     } from '../models/JobDto';
+import { JobExecutionDto    , JobExecutionDtoObjectEnum          } from '../models/JobExecutionDto';
+import { LowOrderQuery   , LowOrderQueryTypeEnum   } from '../models/LowOrderQuery';
+import { LowOrderQueryValue } from '../models/LowOrderQueryValue';
+import { PatchTaskExecutionDto , PatchTaskExecutionDtoStatusEnum    } from '../models/PatchTaskExecutionDto';
+import { Query, QueryTypeEnum   } from '../models/Query';
+import { TaskDto      , TaskDtoObjectEnum     } from '../models/TaskDto';
+import { TaskExecutionDto , TaskExecutionDtoObjectEnum      , TaskExecutionDtoStatusEnum    } from '../models/TaskExecutionDto';
+import { UpdateJobDto    , UpdateJobDtoStatusEnum          } from '../models/UpdateJobDto';
+import { UpdateTaskDto } from '../models/UpdateTaskDto';
+import { UpdateVariableDto  , UpdateVariableDtoStatusEnum      } from '../models/UpdateVariableDto';
+import { VariableDto  , VariableDtoStatusEnum     , VariableDtoObjectEnum     } from '../models/VariableDto';
+
+/* tslint:disable:no-unused-variable */
+let primitives = [
+                    "string",
+                    "boolean",
+                    "double",
+                    "integer",
+                    "long",
+                    "float",
+                    "number",
+                    "any"
+                 ];
+
+const supportedMediaTypes: { [mediaType: string]: number } = {
+  "application/json": Infinity,
+  "application/octet-stream": 0,
+  "application/x-www-form-urlencoded": 0
+}
+
+
+let enumsMap: Set<string> = new Set<string>([
+    "CreateJobDtoStatusEnum",
+    "CreateVariableDtoStatusEnum",
+    "FileDtoObjectEnum",
+    "FindVariablesRequestTypeEnum",
+    "GetFiles200ResponseObjectEnum",
+    "GetJobExecutions200ResponseObjectEnum",
+    "GetJobs200ResponseObjectEnum",
+    "GetTasks200ResponseObjectEnum",
+    "GetVariables200ResponseObjectEnum",
+    "HighOrderQueryTypeEnum",
+    "JobDtoStatusEnum",
+    "JobDtoObjectEnum",
+    "JobExecutionDtoObjectEnum",
+    "LowOrderQueryTypeEnum",
+    "PatchTaskExecutionDtoStatusEnum",
+    "QueryTypeEnum",
+    "TaskDtoObjectEnum",
+    "TaskExecutionDtoObjectEnum",
+    "TaskExecutionDtoStatusEnum",
+    "UpdateJobDtoStatusEnum",
+    "UpdateVariableDtoStatusEnum",
+    "VariableDtoStatusEnum",
+    "VariableDtoObjectEnum",
+]);
+
+let typeMap: {[index: string]: any} = {
+    "CreateJobDto": CreateJobDto,
+    "CreateJobExecutionDto": CreateJobExecutionDto,
+    "CreateTaskDto": CreateTaskDto,
+    "CreateVariableDto": CreateVariableDto,
+    "FileDto": FileDto,
+    "FindVariablesRequest": FindVariablesRequest,
+    "GetFiles200Response": GetFiles200Response,
+    "GetJobExecutionById400Response": GetJobExecutionById400Response,
+    "GetJobExecutions200Response": GetJobExecutions200Response,
+    "GetJobs200Response": GetJobs200Response,
+    "GetTasks200Response": GetTasks200Response,
+    "GetVariables200Response": GetVariables200Response,
+    "HighOrderQuery": HighOrderQuery,
+    "JobDto": JobDto,
+    "JobExecutionDto": JobExecutionDto,
+    "LowOrderQuery": LowOrderQuery,
+    "LowOrderQueryValue": LowOrderQueryValue,
+    "PatchTaskExecutionDto": PatchTaskExecutionDto,
+    "Query": Query,
+    "TaskDto": TaskDto,
+    "TaskExecutionDto": TaskExecutionDto,
+    "UpdateJobDto": UpdateJobDto,
+    "UpdateTaskDto": UpdateTaskDto,
+    "UpdateVariableDto": UpdateVariableDto,
+    "VariableDto": VariableDto,
+}
+
+export class ObjectSerializer {
+    public static findCorrectType(data: any, expectedType: string) {
+        if (data == undefined) {
+            return expectedType;
+        } else if (primitives.indexOf(expectedType.toLowerCase()) !== -1) {
+            return expectedType;
+        } else if (expectedType === "Date") {
+            return expectedType;
+        } else {
+            if (enumsMap.has(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)
+                }
+            }
+        }
+    }
+
+    public static serialize(data: any, type: string, format: string) {
+        if (data == undefined) {
+            return data;
+        } else if (primitives.indexOf(type.toLowerCase()) !== -1) {
+            return data;
+        } else if (type.lastIndexOf("Array<", 0) === 0) { // string.startsWith pre es6
+            let subType: string = type.replace("Array<", ""); // Array<Type> => Type>
+            subType = subType.substring(0, subType.length - 1); // Type> => Type
+            let transformedData: any[] = [];
+            for (let date of data) {
+                transformedData.push(ObjectSerializer.serialize(date, subType, format));
+            }
+            return transformedData;
+        } else if (type === "Date") {
+            if (format == "date") {
+                let month = data.getMonth()+1
+                month = month < 10 ? "0" + month.toString() : month.toString()
+                let day = data.getDate();
+                day = day < 10 ? "0" + day.toString() : day.toString();
+
+                return data.getFullYear() + "-" + month + "-" + day;
+            } else {
+                return data.toISOString();
+            }
+        } else {
+            if (enumsMap.has(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: {[index: string]: any} = {};
+            for (let attributeType of attributeTypes) {
+                instance[attributeType.baseName] = ObjectSerializer.serialize(data[attributeType.name], attributeType.type, attributeType.format);
+            }
+            return instance;
+        }
+    }
+
+    public static deserialize(data: any, type: string, format: string) {
+        // 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 (type.lastIndexOf("Array<", 0) === 0) { // string.startsWith pre es6
+            let subType: string = type.replace("Array<", ""); // Array<Type> => Type>
+            subType = subType.substring(0, subType.length - 1); // Type> => Type
+            let transformedData: any[] = [];
+            for (let date of data) {
+                transformedData.push(ObjectSerializer.deserialize(date, subType, format));
+            }
+            return transformedData;
+        } else if (type === "Date") {
+            return new Date(data);
+        } else {
+            if (enumsMap.has(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 attributeType of attributeTypes) {
+                let value = ObjectSerializer.deserialize(data[attributeType.baseName], attributeType.type, attributeType.format);
+                if (value !== undefined) {
+                    instance[attributeType.name] = value;
+                }
+            }
+            return instance;
+        }
+    }
+
+
+    /**
+     * Normalize media type
+     *
+     * We currently do not handle any media types attributes, i.e. anything
+     * after a semicolon. All content is assumed to be UTF-8 compatible.
+     */
+    public static normalizeMediaType(mediaType: string | undefined): string | undefined {
+        if (mediaType === undefined) {
+            return undefined;
+        }
+        return mediaType.split(";")[0].trim().toLowerCase();
+    }
+
+    /**
+     * From a list of possible media types, choose the one we can handle best.
+     *
+     * The order of the given media types does not have any impact on the choice
+     * made.
+     */
+    public static getPreferredMediaType(mediaTypes: Array<string>): string {
+        /** According to OAS 3 we should default to json */
+        if (!mediaTypes) {
+            return "application/json";
+        }
+
+        const normalMediaTypes = mediaTypes.map(this.normalizeMediaType);
+        let selectedMediaType: string | undefined = undefined;
+        let selectedRank: number = -Infinity;
+        for (const mediaType of normalMediaTypes) {
+            if (supportedMediaTypes[mediaType!] > selectedRank) {
+                selectedMediaType = mediaType;
+                selectedRank = supportedMediaTypes[mediaType!];
+            }
+        }
+
+        if (selectedMediaType === undefined) {
+            throw new Error("None of the given media types are supported: " + mediaTypes.join(", "));
+        }
+
+        return selectedMediaType!;
+    }
+
+    /**
+     * Convert data to a string according the given media type
+     */
+    public static stringify(data: any, mediaType: string): string {
+        if (mediaType === "text/plain") {
+            return String(data);
+        }
+
+        if (mediaType === "application/json") {
+            return JSON.stringify(data);
+        }
+
+        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.stringify.");
+    }
+
+    /**
+     * Parse data from a string according to the given media type
+     */
+    public static parse(rawData: string, mediaType: string | undefined) {
+        if (mediaType === undefined) {
+            throw new Error("Cannot parse content. No Content-Type defined.");
+        }
+
+        if (mediaType === "text/plain") {
+            return rawData;
+        }
+
+        if (mediaType === "application/json") {
+            return JSON.parse(rawData);
+        }
+
+        if (mediaType === "text/html") {
+            return rawData;
+        }
+
+        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.parse.");
+    }
+}

package/models/PatchTaskExecutionDto.ts

@@ -1,10 +1,8 @@
-/* tslint:disable */
-/* eslint-disable */
 /**
  * Product-Live API
  * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
  *
- * The version of the OpenAPI document: 2.5.1
+ * OpenAPI spec version: 2.8.1
  * 
  *
  * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
@@ -12,83 +10,43 @@
  * Do not edit the class manually.
  */
 
-import { exists, mapValues } from '../runtime';
-/**
- * 
- * @export
- * @interface PatchTaskExecutionDto
- */
-export interface PatchTaskExecutionDto {
-    /**
-     * 
-     * @type {string}
-     * @memberof PatchTaskExecutionDto
-     */
-    id: string;
-    /**
-     * 
-     * @type {string}
-     * @memberof PatchTaskExecutionDto
-     */
-    status: PatchTaskExecutionDtoStatusEnum;
-    /**
-     * 
-     * @type {{ [key: string]: any; }}
-     * @memberof PatchTaskExecutionDto
-     */
-    output?: { [key: string]: any; };
-}
-
-
-/**
- * @export
- */
-export const PatchTaskExecutionDtoStatusEnum = {
-    Failed: 'FAILED',
-    Completed: 'COMPLETED'
-} as const;
-export type PatchTaskExecutionDtoStatusEnum = typeof PatchTaskExecutionDtoStatusEnum[keyof typeof PatchTaskExecutionDtoStatusEnum];
-
-
-/**
- * Check if a given object implements the PatchTaskExecutionDto interface.
- */
-export function instanceOfPatchTaskExecutionDto(value: object): boolean {
-    let isInstance = true;
-    isInstance = isInstance && "id" in value;
-    isInstance = isInstance && "status" in value;
-
-    return isInstance;
-}
-
-export function PatchTaskExecutionDtoFromJSON(json: any): PatchTaskExecutionDto {
-    return PatchTaskExecutionDtoFromJSONTyped(json, false);
-}
-
-export function PatchTaskExecutionDtoFromJSONTyped(json: any, ignoreDiscriminator: boolean): PatchTaskExecutionDto {
-    if ((json === undefined) || (json === null)) {
-        return json;
+import { HttpFile } from '../http/http';
+
+export class PatchTaskExecutionDto {
+    'id': string;
+    'status': PatchTaskExecutionDtoStatusEnum;
+    'output'?: { [key: string]: any; };
+
+    static readonly discriminator: string | undefined = undefined;
+
+    static readonly attributeTypeMap: Array<{name: string, baseName: string, type: string, format: string}> = [
+        {
+            "name": "id",
+            "baseName": "id",
+            "type": "string",
+            "format": ""
+        },
+        {
+            "name": "status",
+            "baseName": "status",
+            "type": "PatchTaskExecutionDtoStatusEnum",
+            "format": ""
+        },
+        {
+            "name": "output",
+            "baseName": "output",
+            "type": "{ [key: string]: any; }",
+            "format": ""
+        }    ];
+
+    static getAttributeTypeMap() {
+        return PatchTaskExecutionDto.attributeTypeMap;
     }
-    return {
-        
-        'id': json['id'],
-        'status': json['status'],
-        'output': !exists(json, 'output') ? undefined : json['output'],
-    };
-}
 
-export function PatchTaskExecutionDtoToJSON(value?: PatchTaskExecutionDto | null): any {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (value === null) {
-        return null;
+    public constructor() {
     }
-    return {
-        
-        'id': value.id,
-        'status': value.status,
-        'output': value.output,
-    };
 }
 
+
+export type PatchTaskExecutionDtoStatusEnum = "FAILED" | "COMPLETED" ;
+