@useapi/midjourney-api/models/ObjectSerializer.ts

TypeScript client library for Midjourney API by useapi.net

export * from '../models/AccountResponse';
export * from '../models/BlendResponse';
export * from '../models/ButtonResponse';
export * from '../models/ButtonResponseErrorUpscaled';
export * from '../models/DescribeResponse';
export * from '../models/ImagineResponse';
export * from '../models/ImagineResponseModerated';
export * from '../models/JobCancelResponse';
export * from '../models/JobResponse';
export * from '../models/JobResponseAttachmentsInner';
export * from '../models/JobResponseChildrenInner';
export * from '../models/JobResponseEmbedsInner';
export * from '../models/JobResponseEmbedsInnerImage';
export * from '../models/JobsBlendPostRequest';
export * from '../models/JobsButtonPostRequest';
export * from '../models/JobsDescribePostRequest';
export * from '../models/JobsImaginePostRequest';
export * from '../models/ResponseError';
export * from '../models/ResponseMaxJobs';

import { AccountResponse } from '../models/AccountResponse';
import { BlendResponse } from '../models/BlendResponse';
import { ButtonResponse } from '../models/ButtonResponse';
import { ButtonResponseErrorUpscaled } from '../models/ButtonResponseErrorUpscaled';
import { DescribeResponse } from '../models/DescribeResponse';
import { ImagineResponse } from '../models/ImagineResponse';
import { ImagineResponseModerated } from '../models/ImagineResponseModerated';
import { JobCancelResponse } from '../models/JobCancelResponse';
import { JobResponse } from '../models/JobResponse';
import { JobResponseAttachmentsInner } from '../models/JobResponseAttachmentsInner';
import { JobResponseChildrenInner } from '../models/JobResponseChildrenInner';
import { JobResponseEmbedsInner } from '../models/JobResponseEmbedsInner';
import { JobResponseEmbedsInnerImage } from '../models/JobResponseEmbedsInnerImage';
import { JobsBlendPostRequest } from '../models/JobsBlendPostRequest';
import { JobsButtonPostRequest } from '../models/JobsButtonPostRequest';
import { JobsDescribePostRequest } from '../models/JobsDescribePostRequest';
import { JobsImaginePostRequest } from '../models/JobsImaginePostRequest';
import { ResponseError } from '../models/ResponseError';
import { ResponseMaxJobs } from '../models/ResponseMaxJobs';

/* tslint:disable:no-unused-variable */
let primitives = [
    "string",
    "boolean",
    "double",
    "integer",
    "long",
    "float",
    "number",
    "any"
];

const supportedMediaTypes: { [mediaType: string]: number } = {
    "application/json": Infinity,
    "application/json-patch+json": 1,
    "application/merge-patch+json": 1,
    "application/strategic-merge-patch+json": 1,
    "application/octet-stream": 0,
    "application/x-www-form-urlencoded": 0
}


let enumsMap: Set<string> = new Set<string>([
    "BlendResponseVerbEnum",
    "BlendResponseStatusEnum",
    "BlendResponseBlendDimensionsEnum",
    "BlendResponseCodeEnum",
    "ButtonResponseVerbEnum",
    "ButtonResponseStatusEnum",
    "ButtonResponseButtonEnum",
    "ButtonResponseCodeEnum",
    "ButtonResponseErrorUpscaledButtonEnum",
    "ButtonResponseErrorUpscaledCodeEnum",
    "DescribeResponseVerbEnum",
    "DescribeResponseStatusEnum",
    "DescribeResponseCodeEnum",
    "ImagineResponseVerbEnum",
    "ImagineResponseStatusEnum",
    "ImagineResponseCodeEnum",
    "ImagineResponseModeratedStatusEnum",
    "ImagineResponseModeratedCodeEnum",
    "JobCancelResponseStatusEnum",
    "JobCancelResponseCodeEnum",
    "JobResponseVerbEnum",
    "JobResponseStatusEnum",
    "JobResponseBlendDimensionsEnum",
    "JobResponseButtonEnum",
    "JobResponseButtonsEnum",
    "JobResponseCodeEnum",
    "JobResponseChildrenInnerButtonEnum",
    "JobsBlendPostRequestBlendDimensionsEnum",
    "JobsButtonPostRequestButtonEnum",
    "ResponseErrorCodeEnum",
    "ResponseMaxJobsCodeEnum",
]);

let typeMap: { [index: string]: any } = {
    "AccountResponse": AccountResponse,
    "BlendResponse": BlendResponse,
    "ButtonResponse": ButtonResponse,
    "ButtonResponseErrorUpscaled": ButtonResponseErrorUpscaled,
    "DescribeResponse": DescribeResponse,
    "ImagineResponse": ImagineResponse,
    "ImagineResponseModerated": ImagineResponseModerated,
    "JobCancelResponse": JobCancelResponse,
    "JobResponse": JobResponse,
    "JobResponseAttachmentsInner": JobResponseAttachmentsInner,
    "JobResponseChildrenInner": JobResponseChildrenInner,
    "JobResponseEmbedsInner": JobResponseEmbedsInner,
    "JobResponseEmbedsInnerImage": JobResponseEmbedsInnerImage,
    "JobsBlendPostRequest": JobsBlendPostRequest,
    "JobsButtonPostRequest": JobsButtonPostRequest,
    "JobsDescribePostRequest": JobsDescribePostRequest,
    "JobsImaginePostRequest": JobsImaginePostRequest,
    "ResponseError": ResponseError,
    "ResponseMaxJobs": ResponseMaxJobs,
}

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.length === 0) {
            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" || mediaType === "application/json-patch+json" || mediaType === "application/merge-patch+json" || mediaType === "application/strategic-merge-patch+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" || mediaType === "application/json-patch+json" || mediaType === "application/merge-patch+json" || mediaType === "application/strategic-merge-patch+json") {
            return JSON.parse(rawData);
        }

        if (mediaType === "text/html") {
            return rawData;
        }

        throw new Error("The mediaType " + mediaType + " is not supported by ObjectSerializer.parse.");
    }
}