#![allow(unused_imports, unused_qualifications, unused_extern_crates)]
extern crate chrono;
extern crate serde_json;
extern crate uuid;

use serde::ser::Serializer;

use models;
use std::collections::HashMap;
use swagger;

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AuthOidc {
    /// Fatcat-specific short name (slug) for remote service being used for authentication.
    #[serde(rename = "provider")]
    pub provider: String,

    /// `SUB` from OIDC protocol. Usually a URL.
    #[serde(rename = "sub")]
    pub sub: String,

    /// `ISS` from OIDC protocol. Usually a stable account username, number, or identifier.
    #[serde(rename = "iss")]
    pub iss: String,

    /// What it sounds like; returned by OIDC, and used as a hint when creating new editor accounts. Fatcat usernames are usually this string with the `provider` slug as a suffix, though some munging may occur.
    #[serde(rename = "preferred_username")]
    pub preferred_username: String,
}

impl AuthOidc {
    pub fn new(provider: String, sub: String, iss: String, preferred_username: String) -> AuthOidc {
        AuthOidc {
            provider: provider,
            sub: sub,
            iss: iss,
            preferred_username: preferred_username,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AuthOidcResult {
    #[serde(rename = "editor")]
    pub editor: models::Editor,

    #[serde(rename = "token")]
    pub token: String,
}

impl AuthOidcResult {
    pub fn new(editor: models::Editor, token: String) -> AuthOidcResult {
        AuthOidcResult { editor: editor, token: token }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AuthTokenResult {
    #[serde(rename = "token")]
    pub token: String,
}

impl AuthTokenResult {
    pub fn new(token: String) -> AuthTokenResult {
        AuthTokenResult { token: token }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ChangelogEntry {
    /// Monotonically increasing sequence number of this changelog entry.
    #[serde(rename = "index")]
    pub index: i64,

    /// Identifier of editgroup accepted/merged in this changelog entry.
    #[serde(rename = "editgroup_id")]
    pub editgroup_id: String,

    /// Date and time when the editgroup was accpeted.
    #[serde(rename = "timestamp")]
    pub timestamp: chrono::DateTime<chrono::Utc>,

    #[serde(rename = "editgroup")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editgroup: Option<models::Editgroup>,
}

impl ChangelogEntry {
    pub fn new(index: i64, editgroup_id: String, timestamp: chrono::DateTime<chrono::Utc>) -> ChangelogEntry {
        ChangelogEntry {
            index: index,
            editgroup_id: editgroup_id,
            timestamp: timestamp,
            editgroup: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ContainerAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::ContainerEntity>,
}

impl ContainerAutoBatch {
    pub fn new(editgroup: models::Editgroup, entity_list: Vec<models::ContainerEntity>) -> ContainerAutoBatch {
        ContainerAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ContainerEntity {
    #[serde(rename = "wikidata_qid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wikidata_qid: Option<String>,

    /// Linking ISSN number (ISSN-L). Should be valid and registered with issn.org
    #[serde(rename = "issnl")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub issnl: Option<String>,

    /// Name of the organization or entity responsible for publication. Not the complete imprint/brand.
    #[serde(rename = "publisher")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher: Option<String>,

    /// Type of container, eg 'journal' or 'proceedings'. See Guide for list of valid types.
    #[serde(rename = "container_type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_type: Option<String>,

    /// Name of the container (eg, Journal title). Required for entity creation.
    #[serde(rename = "name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<serde_json::Value>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    // Note: inline enums are not fully supported by swagger-codegen
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

impl ContainerEntity {
    pub fn new() -> ContainerEntity {
        ContainerEntity {
            wikidata_qid: None,
            issnl: None,
            publisher: None,
            container_type: None,
            name: None,
            edit_extra: None,
            extra: None,
            redirect: None,
            revision: None,
            ident: None,
            state: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreatorAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::CreatorEntity>,
}

impl CreatorAutoBatch {
    pub fn new(editgroup: models::Editgroup, entity_list: Vec<models::CreatorEntity>) -> CreatorAutoBatch {
        CreatorAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct CreatorEntity {
    /// Wikidata entity QID
    #[serde(rename = "wikidata_qid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wikidata_qid: Option<String>,

    /// ORCiD (https://orcid.org) identifier
    #[serde(rename = "orcid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orcid: Option<String>,

    /// In English commonly the last, or family name, but ordering is context and culture specific.
    #[serde(rename = "surname")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub surname: Option<String>,

    /// In English commonly the first name, but ordering is context and culture specific.
    #[serde(rename = "given_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub given_name: Option<String>,

    /// Name as should be displayed in web interface or in author lists (not index/sorted). Required for valid entities.
    #[serde(rename = "display_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub display_name: Option<String>,

    // Note: inline enums are not fully supported by swagger-codegen
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<serde_json::Value>,
}

impl CreatorEntity {
    pub fn new() -> CreatorEntity {
        CreatorEntity {
            wikidata_qid: None,
            orcid: None,
            surname: None,
            given_name: None,
            display_name: None,
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Editgroup {
    /// Fatcat identifier for this editgroup. Assigned on creation.
    #[serde(rename = "editgroup_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editgroup_id: Option<String>,

    /// Fatcat identifer of editor that created this editgroup.
    #[serde(rename = "editor_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor_id: Option<String>,

    /// Complete editor object identified by `container_id` field. Only included in GET responses.
    #[serde(rename = "editor")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor: Option<models::Editor>,

    /// For accepted/merged editgroups, the changelog index that the accept occured at. WARNING: not populated in all contexts that an editgroup could be included in a response.
    #[serde(rename = "changelog_index")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub changelog_index: Option<i64>,

    /// Timestamp when this editgroup was first created.
    #[serde(rename = "created")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created: Option<chrono::DateTime<chrono::Utc>>,

    /// Timestamp when this editgroup was most recently submitted for review. If withdrawn, or never submitted, will be `null`.
    #[serde(rename = "submitted")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub submitted: Option<chrono::DateTime<chrono::Utc>>,

    /// Comment describing the changes in this editgroup. Can be updated with PUT request.
    #[serde(rename = "description")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,

    /// Free-form JSON metadata attached to this editgroup. Eg, metadata provenance, or script user-agent details. See guide for (unenforced) schema norms.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests.
    #[serde(rename = "annotations")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotations: Option<Vec<models::EditgroupAnnotation>>,

    #[serde(rename = "edits")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edits: Option<models::EditgroupEdits>,
}

impl Editgroup {
    pub fn new() -> Editgroup {
        Editgroup {
            editgroup_id: None,
            editor_id: None,
            editor: None,
            changelog_index: None,
            created: None,
            submitted: None,
            description: None,
            extra: None,
            annotations: None,
            edits: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EditgroupAnnotation {
    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "annotation_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub annotation_id: Option<String>,

    /// Editgroup that this annotation applies to. Set automatically in creations based on URL parameter.
    #[serde(rename = "editgroup_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editgroup_id: Option<String>,

    /// Defaults to editor created the annotation via POST request.
    #[serde(rename = "editor_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor_id: Option<String>,

    /// Only included in GET responses; ignored in PUT or POST requests.
    #[serde(rename = "editor")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor: Option<models::Editor>,

    /// Timestamp when annotation was first created.
    #[serde(rename = "created")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub created: Option<chrono::DateTime<chrono::Utc>>,

    #[serde(rename = "comment_markdown")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comment_markdown: Option<String>,

    /// Additional free-form JSON metadata that can be included as part of the annotation (or even as the primary annotation itself). See guide for details.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,
}

impl EditgroupAnnotation {
    pub fn new() -> EditgroupAnnotation {
        EditgroupAnnotation {
            annotation_id: None,
            editgroup_id: None,
            editor_id: None,
            editor: None,
            created: None,
            comment_markdown: None,
            extra: None,
        }
    }
}

/// Only included in GET responses, and not in all contexts. Do not include this field in PUT or POST requests.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EditgroupEdits {
    #[serde(rename = "containers")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub containers: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "creators")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creators: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "files")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "filesets")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filesets: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "webcaptures")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webcaptures: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "releases")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub releases: Option<Vec<models::EntityEdit>>,

    #[serde(rename = "works")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub works: Option<Vec<models::EntityEdit>>,
}

impl EditgroupEdits {
    pub fn new() -> EditgroupEdits {
        EditgroupEdits {
            containers: None,
            creators: None,
            files: None,
            filesets: None,
            webcaptures: None,
            releases: None,
            works: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Editor {
    /// Fatcat identifier for the editor. Can not be changed.
    #[serde(rename = "editor_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub editor_id: Option<String>,

    /// Username/handle (short slug-like string) to identify this editor. May be changed at any time by the editor; use the `editor_id` as a persistend identifer.
    #[serde(rename = "username")]
    pub username: String,

    /// Whether this editor has the `admin` role.
    #[serde(rename = "is_admin")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_admin: Option<bool>,

    /// Whether this editor is a bot (as opposed to a human making manual edits)
    #[serde(rename = "is_bot")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_bot: Option<bool>,

    /// Whether this editor's account is enabled (if not API tokens and web logins will not work).
    #[serde(rename = "is_active")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub is_active: Option<bool>,
}

impl Editor {
    pub fn new(username: String) -> Editor {
        Editor {
            editor_id: None,
            username: username,
            is_admin: None,
            is_bot: None,
            is_active: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EntityEdit {
    /// Unique UUID for this specific edit object.
    #[serde(rename = "edit_id")]
    pub edit_id: String,

    /// Fatcat identifier of the entity this edit is mutating.
    #[serde(rename = "ident")]
    pub ident: String,

    /// Entity revision that this edit will set the entity to. May be `null` in the case of deletions.
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// Revision of entity just before this edit. May be used in the future to prevent edit race conditions.
    #[serde(rename = "prev_revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prev_revision: Option<String>,

    /// When an edit is to merge entities (redirect one to another), this is the entity fatcat identifier for the target entity.
    #[serde(rename = "redirect_ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect_ident: Option<String>,

    /// Editgroup identifier that this edit is part of.
    #[serde(rename = "editgroup_id")]
    pub editgroup_id: String,

    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,
}

impl EntityEdit {
    pub fn new(edit_id: String, ident: String, editgroup_id: String) -> EntityEdit {
        EntityEdit {
            edit_id: edit_id,
            ident: ident,
            revision: None,
            prev_revision: None,
            redirect_ident: None,
            editgroup_id: editgroup_id,
            extra: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EntityHistoryEntry {
    #[serde(rename = "edit")]
    pub edit: models::EntityEdit,

    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "changelog_entry")]
    pub changelog_entry: models::ChangelogEntry,
}

impl EntityHistoryEntry {
    pub fn new(edit: models::EntityEdit, editgroup: models::Editgroup, changelog_entry: models::ChangelogEntry) -> EntityHistoryEntry {
        EntityHistoryEntry {
            edit: edit,
            editgroup: editgroup,
            changelog_entry: changelog_entry,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ErrorResponse {
    #[serde(rename = "success")]
    pub success: bool,

    #[serde(rename = "error")]
    pub error: String,

    #[serde(rename = "message")]
    pub message: String,
}

impl ErrorResponse {
    pub fn new(success: bool, error: String, message: String) -> ErrorResponse {
        ErrorResponse {
            success: success,
            error: error,
            message: message,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::FileEntity>,
}

impl FileAutoBatch {
    pub fn new(editgroup: models::Editgroup, entity_list: Vec<models::FileEntity>) -> FileAutoBatch {
        FileAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileEntity {
    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
    #[serde(rename = "releases")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub releases: Option<Vec<models::ReleaseEntity>>,

    /// Set of identifier of release entities this file represents a full manifestation of. Usually a single release, but some files contain content of multiple full releases (eg, an issue of a journal).
    #[serde(rename = "release_ids")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_ids: Option<Vec<String>>,

    #[serde(rename = "mimetype")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mimetype: Option<String>,

    #[serde(rename = "urls")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub urls: Option<Vec<models::FileUrl>>,

    /// SHA-256 hash of data, in hex encoding
    #[serde(rename = "sha256")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha256: Option<String>,

    /// SHA-1 hash of data, in hex encoding
    #[serde(rename = "sha1")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha1: Option<String>,

    /// MD5 hash of data, in hex encoding
    #[serde(rename = "md5")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub md5: Option<String>,

    /// Size of file in bytes. Non-zero.
    #[serde(rename = "size")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<serde_json::Value>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    // Note: inline enums are not fully supported by swagger-codegen
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

impl FileEntity {
    pub fn new() -> FileEntity {
        FileEntity {
            releases: None,
            release_ids: None,
            mimetype: None,
            urls: None,
            sha256: None,
            sha1: None,
            md5: None,
            size: None,
            edit_extra: None,
            extra: None,
            redirect: None,
            revision: None,
            ident: None,
            state: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FileUrl {
    /// URL/URI pointing directly to a machine retrievable copy of this exact file.
    #[serde(rename = "url")]
    pub url: String,

    /// Indicates type of host this URL points to. Eg, \"publisher\", \"repository\", \"webarchive\". See guide for list of acceptable values.
    #[serde(rename = "rel")]
    pub rel: String,
}

impl FileUrl {
    pub fn new(url: String, rel: String) -> FileUrl {
        FileUrl { url: url, rel: rel }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FilesetAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::FilesetEntity>,
}

impl FilesetAutoBatch {
    pub fn new(editgroup: models::Editgroup, entity_list: Vec<models::FilesetEntity>) -> FilesetAutoBatch {
        FilesetAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FilesetEntity {
    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
    #[serde(rename = "releases")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub releases: Option<Vec<models::ReleaseEntity>>,

    /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
    #[serde(rename = "release_ids")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_ids: Option<Vec<String>>,

    #[serde(rename = "urls")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub urls: Option<Vec<models::FilesetUrl>>,

    #[serde(rename = "manifest")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub manifest: Option<Vec<models::FilesetFile>>,

    // Note: inline enums are not fully supported by swagger-codegen
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<serde_json::Value>,
}

impl FilesetEntity {
    pub fn new() -> FilesetEntity {
        FilesetEntity {
            releases: None,
            release_ids: None,
            urls: None,
            manifest: None,
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FilesetFile {
    /// Path name of file within this fileset (eg, directory)
    #[serde(rename = "path")]
    pub path: String,

    /// File size in bytes
    #[serde(rename = "size")]
    pub size: i64,

    /// MD5 hash of data, in hex encoding
    #[serde(rename = "md5")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub md5: Option<String>,

    /// SHA-1 hash of data, in hex encoding
    #[serde(rename = "sha1")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha1: Option<String>,

    /// SHA-256 hash of data, in hex encoding
    #[serde(rename = "sha256")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha256: Option<String>,

    /// Free-form additional metadata about this specific file in the set. Eg, `mimetype`. See guide for nomative (but unenforced) schema fields.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,
}

impl FilesetFile {
    pub fn new(path: String, size: i64) -> FilesetFile {
        FilesetFile {
            path: path,
            size: size,
            md5: None,
            sha1: None,
            sha256: None,
            extra: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct FilesetUrl {
    #[serde(rename = "url")]
    pub url: String,

    /// Indicates type of host this URL points to. See guide for list of acceptable values.
    #[serde(rename = "rel")]
    pub rel: String,
}

impl FilesetUrl {
    pub fn new(url: String, rel: String) -> FilesetUrl {
        FilesetUrl { url: url, rel: rel }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReleaseAbstract {
    /// SHA-1 hash of data, in hex encoding
    #[serde(rename = "sha1")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha1: Option<String>,

    /// Abstract content. May be encoded, as per `mimetype` field, but only string/text content may be included.
    #[serde(rename = "content")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,

    /// Mimetype of abstract contents. `text/plain` is the default if content isn't encoded.
    #[serde(rename = "mimetype")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mimetype: Option<String>,

    /// ISO language code of the abstract. Same semantics as release `language` field.
    #[serde(rename = "lang")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<String>,
}

impl ReleaseAbstract {
    pub fn new() -> ReleaseAbstract {
        ReleaseAbstract {
            sha1: None,
            content: None,
            mimetype: None,
            lang: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReleaseAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::ReleaseEntity>,
}

impl ReleaseAutoBatch {
    pub fn new(editgroup: models::Editgroup, entity_list: Vec<models::ReleaseEntity>) -> ReleaseAutoBatch {
        ReleaseAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReleaseContrib {
    /// Internally assigned zero-indexed sequence number of contribution. Authors should come first; this encodes the order of attriubtion.
    #[serde(rename = "index")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub index: Option<i64>,

    /// If known, indicates the creator entity this contribution was made by.
    #[serde(rename = "creator_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creator_id: Option<String>,

    /// Complete creator entity. Only returned in GET responses, and only if `contribs` included in the `expand` query parameter.
    #[serde(rename = "creator")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub creator: Option<models::CreatorEntity>,

    /// Full name of the contributor as typeset in the release.
    #[serde(rename = "raw_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub raw_name: Option<String>,

    /// In English commonly the first name, but ordering is context and culture specific.
    #[serde(rename = "given_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub given_name: Option<String>,

    /// In English commonly the last, or family name, but ordering is context and culture specific.
    #[serde(rename = "surname")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub surname: Option<String>,

    /// Short string (slug) indicating type of contribution (eg, \"author\", \"translator\"). See guide for list of accpeted values.
    #[serde(rename = "role")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role: Option<String>,

    /// Raw affiliation string as displayed in text
    #[serde(rename = "raw_affiliation")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub raw_affiliation: Option<String>,

    /// Additional free-form JSON metadata about this contributor/contribution. See guide for normative schema.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,
}

impl ReleaseContrib {
    pub fn new() -> ReleaseContrib {
        ReleaseContrib {
            index: None,
            creator_id: None,
            creator: None,
            raw_name: None,
            given_name: None,
            surname: None,
            role: None,
            raw_affiliation: None,
            extra: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReleaseEntity {
    #[serde(rename = "abstracts")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub abstracts: Option<Vec<models::ReleaseAbstract>>,

    #[serde(rename = "refs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub refs: Option<Vec<models::ReleaseRef>>,

    #[serde(rename = "contribs")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contribs: Option<Vec<models::ReleaseContrib>>,

    /// Short string (slug) name of license under which release is openly published (if applicable).
    #[serde(rename = "license_slug")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub license_slug: Option<String>,

    /// Primary language of the content of the full release. Two-letter RFC1766/ISO639-1 language code, with some custom extensions/additions. See guide.
    #[serde(rename = "language")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,

    /// Name, usually English, of the entity or institution responsible for publication of this release. Not necessarily the imprint/brand. See guide.
    #[serde(rename = "publisher")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub publisher: Option<String>,

    /// For, eg, updated technical reports or software packages, where the version string may be the only field disambiguating between releases.
    #[serde(rename = "version")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub version: Option<String>,

    /// For, eg, technical reports, which are published in series or assigned some other institutional or container-specific identifier.
    #[serde(rename = "number")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number: Option<String>,

    /// Either a single page number (\"first page\") or a range of pages separated by a dash (\"-\"). See guide for details.
    #[serde(rename = "pages")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pages: Option<String>,

    /// Issue number of volume/container that this release was published in. Sometimes coresponds to a month number in the year, but can be any string. See guide.
    #[serde(rename = "issue")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub issue: Option<String>,

    /// Volume number of container that this release was published in. Often corresponds to the \"Nth\" year of publication, but can be any string. See guide.
    #[serde(rename = "volume")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume: Option<String>,

    /// Set of external identifiers for this release.
    #[serde(rename = "ext_ids")]
    pub ext_ids: models::ReleaseExtIds,

    /// Year corresponding with `withdrawn_date` like `release_year`/`release_date`.
    #[serde(rename = "withdrawn_year")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawn_year: Option<i64>,

    /// Full date when this release was formally withdrawn (if applicable). ISO format, like `release_date`.
    #[serde(rename = "withdrawn_date")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawn_date: Option<chrono::NaiveDate>,

    /// Type of withdrawl or retraction of this release, if applicable. If release has not been withdrawn, should be `null` (aka, not set, not the string \"null\" or an empty string).
    #[serde(rename = "withdrawn_status")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawn_status: Option<String>,

    /// Year when this release was formally published. Must match `release_date` if that field is set; this field exists because sometimes only the year is known.
    #[serde(rename = "release_year")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_year: Option<i64>,

    /// Full date when this release was formally published. ISO format, like `2019-03-05`. See guide for semantics.
    #[serde(rename = "release_date")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_date: Option<chrono::NaiveDate>,

    /// The stage of publication of this specific release. See guide for valid values and semantics.
    #[serde(rename = "release_stage")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_stage: Option<String>,

    /// \"Type\" or \"medium\" that this release is published as. See guide for valid values.
    #[serde(rename = "release_type")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_type: Option<String>,

    /// Used to link this release to a container entity that the release was published as part of.
    #[serde(rename = "container_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_id: Option<String>,

    /// Complete webcapture entities identified by `webcapture_ids` field. Only included in GET responses when `webcaptures` included in `expand` parameter; ignored in PUT or POST requests.
    #[serde(rename = "webcaptures")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub webcaptures: Option<Vec<models::WebcaptureEntity>>,

    /// Complete file entities identified by `filesets_ids` field. Only included in GET responses when `filesets` included in `expand` parameter; ignored in PUT or POST requests.
    #[serde(rename = "filesets")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filesets: Option<Vec<models::FilesetEntity>>,

    /// Complete file entities identified by `file_ids` field. Only included in GET responses when `files` included in `expand` parameter; ignored in PUT or POST requests.
    #[serde(rename = "files")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub files: Option<Vec<models::FileEntity>>,

    /// Complete container entity identified by `container_id` field. Only included in GET reponses when `container` included in `expand` parameter; ignored in PUT or POST requests.
    #[serde(rename = "container")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container: Option<models::ContainerEntity>,

    /// Identifier of work this release is part of. In creation (POST) requests, a work entity will be created automatically if this field is not set.
    #[serde(rename = "work_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub work_id: Option<String>,

    /// Title in original language if `title` field has been translated. See guide for details.
    #[serde(rename = "original_title")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub original_title: Option<String>,

    /// Subtitle of release. In many cases, better to merge with title than include as separate field (unless combined title would be very long). See guide for details.
    #[serde(rename = "subtitle")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subtitle: Option<String>,

    /// Required for valid entities. The title used in citations and for display. Sometimes the English translation of title e even if release content is not English.
    #[serde(rename = "title")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,

    // Note: inline enums are not fully supported by swagger-codegen
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<serde_json::Value>,
}

impl ReleaseEntity {
    pub fn new(ext_ids: models::ReleaseExtIds) -> ReleaseEntity {
        ReleaseEntity {
            abstracts: None,
            refs: None,
            contribs: None,
            license_slug: None,
            language: None,
            publisher: None,
            version: None,
            number: None,
            pages: None,
            issue: None,
            volume: None,
            ext_ids: ext_ids,
            withdrawn_year: None,
            withdrawn_date: None,
            withdrawn_status: None,
            release_year: None,
            release_date: None,
            release_stage: None,
            release_type: None,
            container_id: None,
            webcaptures: None,
            filesets: None,
            files: None,
            container: None,
            work_id: None,
            original_title: None,
            subtitle: None,
            title: None,
            state: None,
            ident: None,
            revision: None,
            redirect: None,
            extra: None,
            edit_extra: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReleaseExtIds {
    /// Digital serde_json::Value Identifier (DOI), mostly for published papers and datasets. Should be registered and resolvable via https://doi.org/
    #[serde(rename = "doi")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub doi: Option<String>,

    /// Wikidata entity QID
    #[serde(rename = "wikidata_qid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wikidata_qid: Option<String>,

    /// ISBN-13, for books. Usually not set for chapters. ISBN-10 should be converted to ISBN-13.
    #[serde(rename = "isbn13")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isbn13: Option<String>,

    /// PubMed Identifier
    #[serde(rename = "pmid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pmid: Option<String>,

    /// PubMed Central Identifier
    #[serde(rename = "pmcid")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pmcid: Option<String>,

    /// CORE (https://core.ac.uk) identifier
    #[serde(rename = "core")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub core: Option<String>,

    /// arXiv (https://arxiv.org) identifier; must include version
    #[serde(rename = "arxiv")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arxiv: Option<String>,

    /// JSTOR work identifier
    #[serde(rename = "jstor")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jstor: Option<String>,

    /// ARK identifier
    #[serde(rename = "ark")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ark: Option<String>,

    /// Microsoft Academic Graph identifier
    #[serde(rename = "mag")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mag: Option<String>,
}

impl ReleaseExtIds {
    pub fn new() -> ReleaseExtIds {
        ReleaseExtIds {
            doi: None,
            wikidata_qid: None,
            isbn13: None,
            pmid: None,
            pmcid: None,
            core: None,
            arxiv: None,
            jstor: None,
            ark: None,
            mag: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ReleaseRef {
    /// Zero-indexed sequence number of this reference in the list of references. Assigned automatically and used internally; don't confuse with `key`.
    #[serde(rename = "index")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub index: Option<i64>,

    /// Optional, fatcat identifier of release entity that this reference is citing.
    #[serde(rename = "target_release_id")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target_release_id: Option<String>,

    /// Additional free-form JSON metadata about this citation. Generally follows Citation Style Language (CSL) JSON schema. See guide for details.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// Short string used to indicate this reference from within the release text; or numbering of references as typeset in the release itself. Optional; don't confuse with `index` field.
    #[serde(rename = "key")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub key: Option<String>,

    /// Year that the cited work was published in.
    #[serde(rename = "year")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,

    /// Name of the container (eg, journal) that the citation work was published as part of. May be an acronym or full name.
    #[serde(rename = "container_name")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub container_name: Option<String>,

    /// Name of the work being cited.
    #[serde(rename = "title")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,

    /// Page number or other indicator of the specific subset of a work being cited. Not to be confused with the first page (or page range) of an entire paper or chapter being cited.
    #[serde(rename = "locator")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub locator: Option<String>,
}

impl ReleaseRef {
    pub fn new() -> ReleaseRef {
        ReleaseRef {
            index: None,
            target_release_id: None,
            extra: None,
            key: None,
            year: None,
            container_name: None,
            title: None,
            locator: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Success {
    #[serde(rename = "success")]
    pub success: bool,

    #[serde(rename = "message")]
    pub message: String,
}

impl Success {
    pub fn new(success: bool, message: String) -> Success {
        Success { success: success, message: message }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebcaptureAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::WebcaptureEntity>,
}

impl WebcaptureAutoBatch {
    pub fn new(editgroup: models::Editgroup, entity_list: Vec<models::WebcaptureEntity>) -> WebcaptureAutoBatch {
        WebcaptureAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebcaptureCdxLine {
    /// \"Sortable URL\" format. See guide for details.
    #[serde(rename = "surt")]
    pub surt: String,

    /// Date and time of capture, in ISO format. UTC, 'Z'-terminated, second (or better) precision.
    #[serde(rename = "timestamp")]
    pub timestamp: chrono::DateTime<chrono::Utc>,

    /// Full URL/URI of resource captured.
    #[serde(rename = "url")]
    pub url: String,

    /// Mimetype of the resource at this URL. May be the Content-Type header, or the actually sniffed file type.
    #[serde(rename = "mimetype")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mimetype: Option<String>,

    /// HTTP status code. Should generally be 200, especially for the primary resource, but may be 3xx (redirect) or even error codes if embedded resources can not be fetched successfully.
    #[serde(rename = "status_code")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status_code: Option<i64>,

    /// Resource (file) size in bytes
    #[serde(rename = "size")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub size: Option<i64>,

    /// SHA-1 hash of data, in hex encoding
    #[serde(rename = "sha1")]
    pub sha1: String,

    /// SHA-256 hash of data, in hex encoding
    #[serde(rename = "sha256")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sha256: Option<String>,
}

impl WebcaptureCdxLine {
    pub fn new(surt: String, timestamp: chrono::DateTime<chrono::Utc>, url: String, sha1: String) -> WebcaptureCdxLine {
        WebcaptureCdxLine {
            surt: surt,
            timestamp: timestamp,
            url: url,
            mimetype: None,
            status_code: None,
            size: None,
            sha1: sha1,
            sha256: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebcaptureEntity {
    /// Full release entities, included in GET responses when `releases` included in `expand` parameter. Ignored if included in PUT or POST requests.
    #[serde(rename = "releases")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub releases: Option<Vec<models::ReleaseEntity>>,

    /// Set of identifier of release entities this fileset represents a full manifestation of. Usually a single release.
    #[serde(rename = "release_ids")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub release_ids: Option<Vec<String>>,

    /// Same format as CDX line timestamp (UTC, etc). Corresponds to the overall capture timestamp. Should generally be the timestamp of capture of the primary resource URL.
    #[serde(rename = "timestamp")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<chrono::DateTime<chrono::Utc>>,

    /// Base URL of the primary resource this is a capture of
    #[serde(rename = "original_url")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub original_url: Option<String>,

    #[serde(rename = "archive_urls")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub archive_urls: Option<Vec<models::WebcaptureUrl>>,

    #[serde(rename = "cdx")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cdx: Option<Vec<models::WebcaptureCdxLine>>,

    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<serde_json::Value>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    // Note: inline enums are not fully supported by swagger-codegen
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

impl WebcaptureEntity {
    pub fn new() -> WebcaptureEntity {
        WebcaptureEntity {
            releases: None,
            release_ids: None,
            timestamp: None,
            original_url: None,
            archive_urls: None,
            cdx: None,
            edit_extra: None,
            extra: None,
            redirect: None,
            revision: None,
            ident: None,
            state: None,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WebcaptureUrl {
    /// URL/URI pointing to archive of this web resource.
    #[serde(rename = "url")]
    pub url: String,

    /// Type of archive endpoint. Usually `wayback` (WBM replay of primary resource), or `warc` (direct URL to a WARC file containing all resources of the capture). See guide for full list.
    #[serde(rename = "rel")]
    pub rel: String,
}

impl WebcaptureUrl {
    pub fn new(url: String, rel: String) -> WebcaptureUrl {
        WebcaptureUrl { url: url, rel: rel }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkAutoBatch {
    #[serde(rename = "editgroup")]
    pub editgroup: models::Editgroup,

    #[serde(rename = "entity_list")]
    pub entity_list: Vec<models::WorkEntity>,
}

impl WorkAutoBatch {
    pub fn new(editgroup: models::Editgroup, entity_list: Vec<models::WorkEntity>) -> WorkAutoBatch {
        WorkAutoBatch {
            editgroup: editgroup,
            entity_list: entity_list,
        }
    }
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct WorkEntity {
    /// Free-form JSON metadata that will be stored with specific entity edits (eg, creation/update/delete).
    #[serde(rename = "edit_extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub edit_extra: Option<serde_json::Value>,

    /// Free-form JSON metadata that will be stored with the other entity metadata. See guide for (unenforced) schema conventions.
    #[serde(rename = "extra")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extra: Option<serde_json::Value>,

    /// base32-encoded unique identifier
    #[serde(rename = "redirect")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub redirect: Option<String>,

    /// UUID (lower-case, dash-separated, hex-encoded 128-bit)
    #[serde(rename = "revision")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub revision: Option<String>,

    /// base32-encoded unique identifier
    #[serde(rename = "ident")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ident: Option<String>,

    // Note: inline enums are not fully supported by swagger-codegen
    #[serde(rename = "state")]
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

impl WorkEntity {
    pub fn new() -> WorkEntity {
        WorkEntity {
            edit_extra: None,
            extra: None,
            redirect: None,
            revision: None,
            ident: None,
            state: None,
        }
    }
}