@space-cow-media/spellbook-client/spellbook-client/models/variant.ts

An Open Api generated client for the Commander Spellbook backend REST API.

/* tslint:disable */
/* eslint-disable */
/**
 * Commander Spellbook API
 * API for Commander Spellbook, the combo database engine for Magic: The Gathering
 *
 * The version of the OpenAPI document: 4.8.19
 * 
 *
 * 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';
import type { FeatureProducedByVariant } from './featureProducedByVariant';
import {
    FeatureProducedByVariantFromJSON,
    FeatureProducedByVariantFromJSONTyped,
    FeatureProducedByVariantToJSON,
    FeatureProducedByVariantToJSONTyped,
} from './featureProducedByVariant';
import type { VariantLegalities } from './variantLegalities';
import {
    VariantLegalitiesFromJSON,
    VariantLegalitiesFromJSONTyped,
    VariantLegalitiesToJSON,
    VariantLegalitiesToJSONTyped,
} from './variantLegalities';
import type { BracketTagEnum } from './bracketTagEnum';
import {
    BracketTagEnumFromJSON,
    BracketTagEnumFromJSONTyped,
    BracketTagEnumToJSON,
    BracketTagEnumToJSONTyped,
} from './bracketTagEnum';
import type { VariantPrices } from './variantPrices';
import {
    VariantPricesFromJSON,
    VariantPricesFromJSONTyped,
    VariantPricesToJSON,
    VariantPricesToJSONTyped,
} from './variantPrices';
import type { VariantStatusEnum } from './variantStatusEnum';
import {
    VariantStatusEnumFromJSON,
    VariantStatusEnumFromJSONTyped,
    VariantStatusEnumToJSON,
    VariantStatusEnumToJSONTyped,
} from './variantStatusEnum';
import type { Combo } from './combo';
import {
    ComboFromJSON,
    ComboFromJSONTyped,
    ComboToJSON,
    ComboToJSONTyped,
} from './combo';
import type { CardInVariant } from './cardInVariant';
import {
    CardInVariantFromJSON,
    CardInVariantFromJSONTyped,
    CardInVariantToJSON,
    CardInVariantToJSONTyped,
} from './cardInVariant';
import type { IdentityEnum } from './identityEnum';
import {
    IdentityEnumFromJSON,
    IdentityEnumFromJSONTyped,
    IdentityEnumToJSON,
    IdentityEnumToJSONTyped,
} from './identityEnum';
import type { TemplateInVariant } from './templateInVariant';
import {
    TemplateInVariantFromJSON,
    TemplateInVariantFromJSONTyped,
    TemplateInVariantToJSON,
    TemplateInVariantToJSONTyped,
} from './templateInVariant';

/**
 * 
 * @export
 * @interface Variant
 */
export interface Variant {
    /**
     * Unique ID for this variant
     * @type {string}
     * @memberof Variant
     */
    id: string;
    /**
     * Variant status for editors
     * 
     * * `N` - New
     * * `D` - Draft
     * * `NR` - Needs Review
     * * `OK` - Ok
     * * `E` - Example
     * * `R` - Restore
     * * `NW` - Not Working
     * @type {VariantStatusEnum}
     * @memberof Variant
     */
    status: VariantStatusEnum;
    /**
     * 
     * @type {Array<CardInVariant>}
     * @memberof Variant
     */
    readonly uses: Array<CardInVariant>;
    /**
     * 
     * @type {Array<TemplateInVariant>}
     * @memberof Variant
     */
    readonly requires: Array<TemplateInVariant>;
    /**
     * 
     * @type {Array<FeatureProducedByVariant>}
     * @memberof Variant
     */
    readonly produces: Array<FeatureProducedByVariant>;
    /**
     * 
     * @type {Array<Combo>}
     * @memberof Variant
     */
    readonly of: Array<Combo>;
    /**
     * 
     * @type {Array<Combo>}
     * @memberof Variant
     */
    readonly includes: Array<Combo>;
    /**
     * 
     * @type {IdentityEnum}
     * @memberof Variant
     */
    identity: IdentityEnum;
    /**
     * 
     * @type {string}
     * @memberof Variant
     */
    readonly manaNeeded: string;
    /**
     * 
     * @type {number}
     * @memberof Variant
     */
    readonly manaValueNeeded: number;
    /**
     * 
     * @type {string}
     * @memberof Variant
     */
    readonly easyPrerequisites: string;
    /**
     * 
     * @type {string}
     * @memberof Variant
     */
    readonly notablePrerequisites: string;
    /**
     * 
     * @type {string}
     * @memberof Variant
     */
    readonly description: string;
    /**
     * 
     * @type {string}
     * @memberof Variant
     */
    readonly notes: string;
    /**
     * 
     * @type {number}
     * @memberof Variant
     */
    readonly popularity: number | null;
    /**
     * Is this from an upcoming set?
     * @type {boolean}
     * @memberof Variant
     */
    spoiler: boolean;
    /**
     * 
     * @type {BracketTagEnum}
     * @memberof Variant
     */
    bracketTag: BracketTagEnum;
    /**
     * 
     * @type {VariantLegalities}
     * @memberof Variant
     */
    readonly legalities: VariantLegalities;
    /**
     * 
     * @type {VariantPrices}
     * @memberof Variant
     */
    readonly prices: VariantPrices;
    /**
     * Number of variants generated by the same generator combos
     * @type {number}
     * @memberof Variant
     */
    readonly variantCount: number;
}



/**
 * Check if a given object implements the Variant interface.
 */
export function instanceOfVariant(value: object): value is Variant {
    if (!('id' in value) || value['id'] === undefined) return false;
    if (!('status' in value) || value['status'] === undefined) return false;
    if (!('uses' in value) || value['uses'] === undefined) return false;
    if (!('requires' in value) || value['requires'] === undefined) return false;
    if (!('produces' in value) || value['produces'] === undefined) return false;
    if (!('of' in value) || value['of'] === undefined) return false;
    if (!('includes' in value) || value['includes'] === undefined) return false;
    if (!('identity' in value) || value['identity'] === undefined) return false;
    if (!('manaNeeded' in value) || value['manaNeeded'] === undefined) return false;
    if (!('manaValueNeeded' in value) || value['manaValueNeeded'] === undefined) return false;
    if (!('easyPrerequisites' in value) || value['easyPrerequisites'] === undefined) return false;
    if (!('notablePrerequisites' in value) || value['notablePrerequisites'] === undefined) return false;
    if (!('description' in value) || value['description'] === undefined) return false;
    if (!('notes' in value) || value['notes'] === undefined) return false;
    if (!('popularity' in value) || value['popularity'] === undefined) return false;
    if (!('spoiler' in value) || value['spoiler'] === undefined) return false;
    if (!('bracketTag' in value) || value['bracketTag'] === undefined) return false;
    if (!('legalities' in value) || value['legalities'] === undefined) return false;
    if (!('prices' in value) || value['prices'] === undefined) return false;
    if (!('variantCount' in value) || value['variantCount'] === undefined) return false;
    return true;
}

export function VariantFromJSON(json: any): Variant {
    return VariantFromJSONTyped(json, false);
}

export function VariantFromJSONTyped(json: any, ignoreDiscriminator: boolean): Variant {
    if (json == null) {
        return json;
    }
    return {
        
        'id': json['id'],
        'status': VariantStatusEnumFromJSON(json['status']),
        'uses': ((json['uses'] as Array<any>).map(CardInVariantFromJSON)),
        'requires': ((json['requires'] as Array<any>).map(TemplateInVariantFromJSON)),
        'produces': ((json['produces'] as Array<any>).map(FeatureProducedByVariantFromJSON)),
        'of': ((json['of'] as Array<any>).map(ComboFromJSON)),
        'includes': ((json['includes'] as Array<any>).map(ComboFromJSON)),
        'identity': IdentityEnumFromJSON(json['identity']),
        'manaNeeded': json['manaNeeded'],
        'manaValueNeeded': json['manaValueNeeded'],
        'easyPrerequisites': json['easyPrerequisites'],
        'notablePrerequisites': json['notablePrerequisites'],
        'description': json['description'],
        'notes': json['notes'],
        'popularity': json['popularity'],
        'spoiler': json['spoiler'],
        'bracketTag': BracketTagEnumFromJSON(json['bracketTag']),
        'legalities': VariantLegalitiesFromJSON(json['legalities']),
        'prices': VariantPricesFromJSON(json['prices']),
        'variantCount': json['variantCount'],
    };
}

export function VariantToJSON(json: any): Variant {
    return VariantToJSONTyped(json, false);
}

export function VariantToJSONTyped(value?: Omit<Variant, 'uses'|'requires'|'produces'|'of'|'includes'|'manaNeeded'|'manaValueNeeded'|'easyPrerequisites'|'notablePrerequisites'|'description'|'notes'|'popularity'|'legalities'|'prices'|'variantCount'> | null, ignoreDiscriminator: boolean = false): any {
    if (value == null) {
        return value;
    }

    return {
        
        'id': value['id'],
        'status': VariantStatusEnumToJSON(value['status']),
        'identity': IdentityEnumToJSON(value['identity']),
        'spoiler': value['spoiler'],
        'bracketTag': BracketTagEnumToJSON(value['bracketTag']),
    };
}