doersiq-types 2.0.0

package/dist/src/Bot.d.ts

@@ -0,0 +1,28 @@
+import { OfficeClassID } from "./OfficeClass.js";
+import { Jurisdiction } from "./Jurisdiction.js";
+import { StateID } from "./State.js";
+import { PartyID } from "./Party.js";
+export declare class Bot {
+    readonly office_id: string;
+    readonly number: string;
+    readonly bot_id: string;
+    readonly name: string;
+    readonly active: boolean;
+    readonly state_id: StateID;
+    readonly district?: number;
+    readonly party_id: PartyID;
+    readonly guidelines: string;
+    readonly topics: string[];
+    readonly jurisdiction_ids: number[];
+    readonly office_class_id: OfficeClassID;
+    readonly office_name?: string;
+    readonly [x: string]: any;
+    constructor(bot: any);
+    static is(bot: any): bot is Bot;
+}
+export declare class BotAux extends Bot {
+    readonly jurisdictions: Jurisdiction[];
+    readonly photo_download_url?: string;
+    constructor(bot: any);
+    static is(bot: any): bot is BotAux;
+}

package/dist/src/Bot.js

@@ -0,0 +1,73 @@
+import { is_office_class_id } from "./OfficeClass.js";
+import { Jurisdiction } from "./Jurisdiction.js";
+import { is_state_id } from "./State.js";
+import { is_party_id } from "./Party.js";
+export class Bot {
+    office_id;
+    number;
+    bot_id;
+    name;
+    active;
+    state_id;
+    district;
+    party_id;
+    guidelines;
+    topics;
+    jurisdiction_ids;
+    office_class_id;
+    office_name;
+    constructor(bot) {
+        if (!Bot.is(bot)) {
+            throw Error("Invalid input.");
+        }
+        this.office_id = bot.office_id;
+        this.number = bot.number;
+        this.bot_id = bot.bot_id;
+        this.name = bot.name;
+        this.active = bot.active;
+        this.state_id = bot.state_id;
+        this.district = bot.district;
+        this.party_id = bot.party_id;
+        this.guidelines = bot.guidelines;
+        this.topics = bot.topics;
+        this.jurisdiction_ids = bot.jurisdiction_ids;
+        this.office_class_id = bot.office_class_id;
+        this.office_name = bot.office_name;
+    }
+    static is(bot) {
+        return (bot !== undefined &&
+            typeof bot.office_id === "string" &&
+            typeof bot.number === "string" &&
+            typeof bot.bot_id === "string" &&
+            typeof bot.name === "string" &&
+            typeof bot.active === "boolean" &&
+            is_state_id(bot.state_id) &&
+            (bot.district === undefined || typeof bot.district === "number") &&
+            is_party_id(bot.party_id) &&
+            typeof bot.guidelines === "string" &&
+            Array.isArray(bot.topics) &&
+            bot.topics.every((topic) => typeof topic === "string") &&
+            Array.isArray(bot.jurisdiction_ids) &&
+            bot.jurisdiction_ids.every((jurisdiction_id) => typeof jurisdiction_id === "number") &&
+            is_office_class_id(bot.office_class_id) &&
+            (bot.office_name === undefined || typeof bot.office_name === "string"));
+    }
+}
+export class BotAux extends Bot {
+    jurisdictions;
+    photo_download_url;
+    constructor(bot) {
+        if (!BotAux.is(bot)) {
+            throw Error("Invalid input.");
+        }
+        super(bot);
+        this.jurisdictions = bot.jurisdictions;
+        this.photo_download_url = bot.photo_download_url;
+    }
+    static is(bot) {
+        return (Bot.is(bot) &&
+            Array.isArray(bot.jurisdictions) &&
+            bot.jurisdictions.every(Jurisdiction.is) &&
+            (bot.photo_download_url === undefined || typeof bot.photo_download_url === "string"));
+    }
+}

package/dist/src/BotDocument.d.ts

@@ -0,0 +1,14 @@
+import { Tweet } from "./Tweet.js";
+export declare class BotDocument {
+    readonly bot_id: string;
+    readonly document_id: string;
+    readonly type: "URL" | "TWEET" | "TWITTER";
+    readonly s3_filename?: string;
+    readonly url?: string;
+    readonly username?: string;
+    readonly vector_keys?: string[];
+    readonly tweet?: Tweet;
+    readonly text?: string;
+    constructor(bot_document: any);
+    static is(bot_document: any): bot_document is BotDocument;
+}

package/dist/src/BotDocument.js

@@ -0,0 +1,38 @@
+import { Tweet } from "./Tweet.js";
+export class BotDocument {
+    bot_id;
+    document_id;
+    type;
+    s3_filename;
+    url;
+    username;
+    vector_keys;
+    tweet;
+    text;
+    constructor(bot_document) {
+        if (!BotDocument.is(bot_document)) {
+            throw Error("Invalid input.");
+        }
+        this.bot_id = bot_document.bot_id;
+        this.document_id = bot_document.document_id;
+        this.type = bot_document.type;
+        this.s3_filename = bot_document.s3_filename;
+        this.url = bot_document.url;
+        this.username = bot_document.username;
+        this.vector_keys = bot_document.vector_keys;
+        this.tweet = bot_document.tweet;
+        this.text = bot_document.text;
+    }
+    static is(bot_document) {
+        return (bot_document !== undefined &&
+            typeof bot_document.bot_id === "string" &&
+            typeof bot_document.document_id === "string" &&
+            typeof bot_document.type === "string" &&
+            (bot_document.s3_filename === undefined || typeof bot_document.s3_filename === "string") &&
+            (bot_document.url === undefined || typeof bot_document.url === "string") &&
+            (bot_document.username === undefined || typeof bot_document.username === "string") &&
+            (bot_document.vector_keys === undefined || Array.isArray(bot_document.vector_keys) && bot_document.vector_keys.every((vector_key) => typeof vector_key === "string")) &&
+            (bot_document.tweet === undefined || Tweet.is(bot_document.tweet)) &&
+            (bot_document.text === undefined || typeof bot_document.text === "string"));
+    }
+}

package/dist/src/Conversation.d.ts

@@ -0,0 +1,16 @@
+import { Message } from "./Message.js";
+export declare class Conversation {
+    readonly user_id: string;
+    readonly conversation_id: string;
+    readonly bot_id: string;
+    readonly mode: "email" | "general";
+    readonly topics?: string[];
+    readonly [x: string]: any;
+    constructor(conversation: any);
+    static is(conversation: any): conversation is Conversation;
+}
+export declare class ConversationAux extends Conversation {
+    readonly messages: Message[];
+    constructor(conversation: any);
+    static is(conversation: any): conversation is ConversationAux;
+}

package/dist/src/Conversation.js

@@ -0,0 +1,42 @@
+import { Message } from "./Message.js";
+export class Conversation {
+    user_id;
+    conversation_id;
+    bot_id;
+    mode;
+    topics;
+    constructor(conversation) {
+        if (!Conversation.is(conversation)) {
+            throw Error("Invalid input.");
+        }
+        this.user_id = conversation.user_id;
+        this.conversation_id = conversation.conversation_id;
+        this.bot_id = conversation.bot_id;
+        this.mode = conversation.mode;
+        this.topics = conversation.topics;
+    }
+    static is(conversation) {
+        return (conversation !== undefined &&
+            typeof conversation.user_id === "string" &&
+            typeof conversation.conversation_id === "string" &&
+            typeof conversation.bot_id === "string" &&
+            ["email", "general"].includes(conversation.mode) &&
+            (conversation.topics === undefined || Array.isArray(conversation.topics) &&
+                conversation.topics.every((topic) => typeof topic === "string")));
+    }
+}
+export class ConversationAux extends Conversation {
+    messages;
+    constructor(conversation) {
+        if (!ConversationAux.is(conversation)) {
+            throw Error("Invalid input.");
+        }
+        super(conversation);
+        this.messages = conversation.messages;
+    }
+    static is(conversation) {
+        return (Conversation.is(conversation) &&
+            Array.isArray(conversation.messages) &&
+            conversation.messages.every(Message.is));
+    }
+}

package/dist/src/DoersAPIError.d.ts

@@ -0,0 +1,4 @@
+export declare class DoersAPIError extends Error {
+    status: number;
+    constructor(status: number, message?: string);
+}

package/dist/src/DoersAPIError.js

@@ -0,0 +1,18 @@
+const default_messages_by_status = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    500: "Internal Server Error",
+    600: "Failed to Parse Output"
+};
+export class DoersAPIError extends Error {
+    status;
+    constructor(status, message) {
+        const default_message = default_messages_by_status[status];
+        super(message !== undefined ? message : default_message !== undefined ? default_message : "Error");
+        this.name = "DoersAPIError";
+        this.status = status;
+    }
+}

package/dist/src/Jurisdiction.d.ts

@@ -0,0 +1,22 @@
+export declare enum JurisdictionLevel {
+    SCHOOL = 0,
+    NATION = 1,
+    STATE = 2,
+    COUNTY = 3,
+    CITY = 4
+}
+export declare function is_jurisdiction_level(jurisdiction_level: any): jurisdiction_level is JurisdictionLevel;
+export declare class Jurisdiction {
+    readonly jurisdiction_id: number;
+    readonly name: string;
+    readonly path: number[];
+    readonly sub_jurisdiction_ids: number[];
+    readonly super_jurisdiction_id?: number;
+    readonly level: JurisdictionLevel;
+    readonly state_jurisdiction_id?: number;
+    readonly county_jurisdiction_id?: number;
+    readonly city_jurisdiction_id?: number;
+    readonly geographic: boolean;
+    constructor(jurisdiction: any);
+    static is(jurisdiction: any): jurisdiction is Jurisdiction;
+}

package/dist/src/Jurisdiction.js

@@ -0,0 +1,53 @@
+export var JurisdictionLevel;
+(function (JurisdictionLevel) {
+    JurisdictionLevel[JurisdictionLevel["SCHOOL"] = 0] = "SCHOOL";
+    JurisdictionLevel[JurisdictionLevel["NATION"] = 1] = "NATION";
+    JurisdictionLevel[JurisdictionLevel["STATE"] = 2] = "STATE";
+    JurisdictionLevel[JurisdictionLevel["COUNTY"] = 3] = "COUNTY";
+    JurisdictionLevel[JurisdictionLevel["CITY"] = 4] = "CITY";
+})(JurisdictionLevel || (JurisdictionLevel = {}));
+export function is_jurisdiction_level(jurisdiction_level) {
+    return [0, 1, 2, 3, 4].includes(jurisdiction_level);
+}
+export class Jurisdiction {
+    jurisdiction_id;
+    name;
+    path;
+    sub_jurisdiction_ids;
+    super_jurisdiction_id;
+    level;
+    state_jurisdiction_id;
+    county_jurisdiction_id;
+    city_jurisdiction_id;
+    geographic;
+    constructor(jurisdiction) {
+        if (!Jurisdiction.is(jurisdiction)) {
+            throw Error("Invalid input.");
+        }
+        this.jurisdiction_id = jurisdiction.jurisdiction_id;
+        this.name = jurisdiction.name;
+        this.path = jurisdiction.path;
+        this.sub_jurisdiction_ids = jurisdiction.sub_jurisdiction_ids;
+        this.super_jurisdiction_id = jurisdiction.super_jurisdiction_id;
+        this.level = jurisdiction.level;
+        this.state_jurisdiction_id = jurisdiction.state_jurisdiction_id;
+        this.county_jurisdiction_id = jurisdiction.county_jurisdiction_id;
+        this.city_jurisdiction_id = jurisdiction.city_jurisdiction_id;
+        this.geographic = jurisdiction.geographic;
+    }
+    static is(jurisdiction) {
+        return (jurisdiction !== undefined &&
+            typeof jurisdiction.jurisdiction_id === "number" &&
+            typeof jurisdiction.name === "string" &&
+            Array.isArray(jurisdiction.path) &&
+            jurisdiction.path.every((jurisdiction_id) => typeof jurisdiction_id === "number") &&
+            Array.isArray(jurisdiction.sub_jurisdiction_ids) &&
+            jurisdiction.sub_jurisdiction_ids.every((jurisdiction_id) => typeof jurisdiction_id === "number") &&
+            is_jurisdiction_level(jurisdiction.level) &&
+            typeof jurisdiction.geographic === "boolean" &&
+            (jurisdiction.super_jurisdiction_id === undefined || typeof jurisdiction.super_jurisdiction_id === "number") &&
+            (jurisdiction.state_jurisdiction_id === undefined || typeof jurisdiction.state_jurisdiction_id === "number") &&
+            (jurisdiction.county_jurisdiction_id === undefined || typeof jurisdiction.county_jurisdiction_id === "number") &&
+            (jurisdiction.city_jurisdiction_id === undefined || typeof jurisdiction.city_jurisdiction_id === "number"));
+    }
+}

package/dist/src/JurisdictionDocument.d.ts

@@ -0,0 +1,15 @@
+export declare class JurisdictionDocument {
+    readonly jurisdiction_id: number;
+    readonly document_id: string;
+    readonly media_id: string;
+    readonly origin: string;
+    readonly s3_filename?: string;
+    readonly time?: string;
+    readonly title: string;
+    readonly type: string;
+    readonly url: string;
+    readonly vector_keys?: string[];
+    readonly location?: string;
+    constructor(jurisdiction_document: any);
+    static is(jurisdiction_document: any): jurisdiction_document is JurisdictionDocument;
+}

package/dist/src/JurisdictionDocument.js

@@ -0,0 +1,44 @@
+export class JurisdictionDocument {
+    jurisdiction_id;
+    document_id;
+    media_id;
+    origin;
+    s3_filename;
+    time;
+    title;
+    type;
+    url;
+    vector_keys;
+    location;
+    constructor(jurisdiction_document) {
+        if (!JurisdictionDocument.is(jurisdiction_document)) {
+            throw Error("Invalid input.");
+        }
+        this.jurisdiction_id = jurisdiction_document.jurisdiction_id;
+        this.document_id = jurisdiction_document.document_id;
+        this.media_id = jurisdiction_document.media_id;
+        this.origin = jurisdiction_document.origin;
+        this.s3_filename = jurisdiction_document.s3_filename;
+        this.time = jurisdiction_document.time;
+        this.title = jurisdiction_document.title;
+        this.type = jurisdiction_document.type;
+        this.url = jurisdiction_document.url;
+        this.vector_keys = jurisdiction_document.vector_keys;
+        this.location = jurisdiction_document.location;
+    }
+    static is(jurisdiction_document) {
+        return (jurisdiction_document !== undefined &&
+            typeof jurisdiction_document.jurisdiction_id === "number" &&
+            typeof jurisdiction_document.document_id === "string" &&
+            typeof jurisdiction_document.media_id === "string" &&
+            typeof jurisdiction_document.origin === "string" &&
+            (jurisdiction_document.s3_filename === undefined || typeof jurisdiction_document.s3_filename === "string") &&
+            (jurisdiction_document.time === undefined || typeof jurisdiction_document.time === "string") &&
+            typeof jurisdiction_document.title === "string" &&
+            typeof jurisdiction_document.type === "string" &&
+            typeof jurisdiction_document.url === "string" &&
+            (jurisdiction_document.vector_keys === undefined || Array.isArray(jurisdiction_document.vector_keys)) &&
+            jurisdiction_document.vector_keys.every((vector_key) => typeof vector_key === "string") &&
+            (jurisdiction_document.location === undefined || typeof jurisdiction_document.location === "string"));
+    }
+}

package/dist/src/Message.d.ts

@@ -0,0 +1,29 @@
+import { Sources } from "./Sources.js";
+export declare class Fragment {
+    readonly text: string;
+    readonly sources: Sources;
+    constructor(fragment: any);
+    static is(fragment: any): fragment is Fragment;
+}
+export declare class Post {
+    text: string;
+    s3_image_filename?: string;
+    s3_image_url?: string;
+    constructor(post: any);
+    static is(post: any): post is Post;
+}
+export declare class Message {
+    readonly user_id: string;
+    readonly message_id: string;
+    readonly conversation_id: string;
+    readonly mode: "email" | "general";
+    readonly role: "user" | "bot";
+    readonly system_prompt?: string;
+    readonly grok_text?: string;
+    readonly fragments?: Fragment[];
+    readonly sources?: Sources;
+    readonly text: string;
+    readonly posts?: Post[];
+    constructor(message: any);
+    static is(message: any): message is Message;
+}

package/dist/src/Message.js

@@ -0,0 +1,79 @@
+import { Sources } from "./Sources.js";
+export class Fragment {
+    text;
+    sources;
+    constructor(fragment) {
+        if (!Fragment.is(fragment)) {
+            throw Error("Invalid input.");
+        }
+        this.text = fragment.text;
+        this.sources = fragment.sources;
+    }
+    static is(fragment) {
+        return (fragment !== undefined &&
+            typeof fragment.text === "string" &&
+            Sources.is(fragment.sources));
+    }
+}
+export class Post {
+    text;
+    s3_image_filename;
+    s3_image_url;
+    constructor(post) {
+        if (!Post.is(post)) {
+            throw Error("Invalid input.");
+        }
+        this.text = post.text;
+        this.s3_image_filename = post.s3_image_filename;
+        this.s3_image_url = post.s3_image_url;
+    }
+    static is(post) {
+        return (post !== undefined &&
+            typeof post.text === "string" &&
+            (post.s3_image_filename === undefined || typeof post.s3_image_filename === "string") &&
+            (post.s3_image_url === undefined || typeof post.s3_image_url === "string"));
+    }
+}
+export class Message {
+    user_id;
+    message_id;
+    conversation_id;
+    mode;
+    role;
+    system_prompt;
+    grok_text;
+    fragments;
+    sources;
+    text;
+    posts;
+    constructor(message) {
+        if (!Message.is(message)) {
+            throw Error("Invalid input.");
+        }
+        this.user_id = message.user_id;
+        this.message_id = message.message_id;
+        this.conversation_id = message.conversation_id;
+        this.mode = message.mode;
+        this.role = message.role;
+        this.system_prompt = message.system_prompt;
+        this.grok_text = message.grok_text;
+        this.fragments = message.fragments;
+        this.sources = message.sources;
+        this.text = message.text;
+        this.posts = message.posts;
+    }
+    static is(message) {
+        return (message !== undefined &&
+            typeof message.user_id === "string" &&
+            typeof message.message_id === "string" &&
+            typeof message.conversation_id === "string" &&
+            ["email", "general"].includes(message.mode) &&
+            ["user", "bot"].includes(message.role) &&
+            (message.system_prompt === undefined || typeof message.system_prompt === "string") &&
+            (message.grok_text === undefined || typeof message.grok_text === "string") &&
+            (message.fragments === undefined || Array.isArray(message.fragments) && message.fragments.every(Fragment.is)) &&
+            (message.sources === undefined || Sources.is(message.sources)) &&
+            typeof message.text === "string" &&
+            (message.posts === undefined || Array.isArray(message.posts) && message.posts.every(Post.is)));
+    }
+}

package/dist/src/OfficeClass.d.ts

@@ -0,0 +1,17 @@
+import { JurisdictionLevel } from "./Jurisdiction.js";
+declare const office_class_ids: readonly ["ORG", "USH", "USS", "STG", "STH", "STS", "STB", "COG", "CIG", "LOB"];
+export type OfficeClassID = typeof office_class_ids[number];
+export declare function is_office_class_id(office_class_id: any): office_class_id is OfficeClassID;
+export interface OfficeClass {
+    office_class_id: OfficeClassID;
+    name: string;
+    type: "candidate" | "organization";
+    office_id_template: string;
+    jurisdiction_level?: JurisdictionLevel;
+    jurisdictions_mutable: Boolean;
+    require_district: Boolean;
+    require_initial_jurisdiction: Boolean;
+    office_names?: string[];
+}
+export declare const office_classes_by_office_class_id: Record<OfficeClassID, OfficeClass>;
+export {};

package/dist/src/OfficeClass.js

@@ -0,0 +1,131 @@
+import { JurisdictionLevel } from "./Jurisdiction.js";
+const office_class_ids = ["ORG", "USH", "USS", "STG", "STH", "STS", "STB", "COG", "CIG", "LOB"];
+export function is_office_class_id(office_class_id) {
+    return office_class_ids.includes(office_class_id);
+}
+export const office_classes_by_office_class_id = {
+    "ORG": {
+        office_class_id: "ORG",
+        name: "Organization",
+        type: "organization",
+        office_id_template: "O-[state_id]",
+        jurisdictions_mutable: true,
+        require_district: false,
+        require_initial_jurisdiction: false
+    },
+    "USH": {
+        office_class_id: "USH",
+        name: "U.S. House",
+        type: "candidate",
+        office_id_template: "H-[state_id]",
+        jurisdictions_mutable: true,
+        require_district: true,
+        require_initial_jurisdiction: false
+    },
+    "USS": {
+        office_class_id: "USS",
+        name: "U.S. Senate",
+        type: "candidate",
+        office_id_template: "S-[state_id]",
+        jurisdiction_level: JurisdictionLevel.STATE,
+        jurisdictions_mutable: false,
+        require_district: false,
+        require_initial_jurisdiction: false
+    },
+    "STG": {
+        office_class_id: "STG",
+        name: "State (Executive) Government",
+        type: "candidate",
+        office_id_template: "[state_id]-G",
+        jurisdiction_level: JurisdictionLevel.STATE,
+        jurisdictions_mutable: false,
+        require_district: false,
+        require_initial_jurisdiction: false,
+        office_names: [
+            "Governor",
+            "Lieutenant Governor",
+            "Secretary of State",
+            "Treasurer",
+            "Auditor",
+            "Attorney General"
+        ]
+    },
+    "STH": {
+        office_class_id: "STH",
+        name: "State House",
+        type: "candidate",
+        office_id_template: "[state_id]-H",
+        jurisdictions_mutable: true,
+        require_district: true,
+        require_initial_jurisdiction: false
+    },
+    "STS": {
+        office_class_id: "STS",
+        name: "State Senate",
+        type: "candidate",
+        office_id_template: "[state_id]-S",
+        jurisdictions_mutable: true,
+        require_district: true,
+        require_initial_jurisdiction: false
+    },
+    "STB": {
+        office_class_id: "STB",
+        name: "State School Board",
+        type: "candidate",
+        office_id_template: "[state_id]-B",
+        jurisdictions_mutable: true,
+        require_district: true,
+        require_initial_jurisdiction: false,
+        office_names: [
+            "Board Member"
+        ]
+    },
+    "COG": {
+        office_class_id: "COG",
+        name: "County Government",
+        type: "candidate",
+        office_id_template: "[state_id]-C",
+        jurisdiction_level: JurisdictionLevel.COUNTY,
+        jurisdictions_mutable: true,
+        require_district: false,
+        require_initial_jurisdiction: true,
+        office_names: [
+            "Mayor",
+            "Councillor",
+            "Commissioner",
+            "Clerk",
+            "Recorder",
+            "Auditor",
+            "Surveyor",
+            "Recorder",
+            "District Attorney",
+            "Sheriff"
+        ]
+    },
+    "CIG": {
+        office_class_id: "CIG",
+        name: "City Government",
+        type: "candidate",
+        office_id_template: "[state_id]-M",
+        jurisdiction_level: JurisdictionLevel.CITY,
+        jurisdictions_mutable: true,
+        require_district: false,
+        require_initial_jurisdiction: true,
+        office_names: [
+            "Mayor",
+            "Councillor"
+        ]
+    },
+    "LOB": {
+        office_class_id: "LOB",
+        name: "Local School Board",
+        type: "candidate",
+        office_id_template: "[state_id]-E",
+        jurisdictions_mutable: true,
+        require_district: false,
+        require_initial_jurisdiction: false,
+        office_names: [
+            "Board Member"
+        ]
+    }
+};

package/dist/src/Party.d.ts

@@ -0,0 +1,10 @@
+declare const party_ids: readonly ["DEM", "REP", "NON", "ETC"];
+export type PartyID = typeof party_ids[number];
+export declare function is_party_id(party_id: any): party_id is PartyID;
+export interface Party {
+    party_id: PartyID;
+    name: string;
+    adjective: string;
+}
+export declare const parties_by_party_id: Record<PartyID, Party>;
+export {};

package/dist/src/Party.js

@@ -0,0 +1,26 @@
+const party_ids = ["DEM", "REP", "NON", "ETC"];
+export function is_party_id(party_id) {
+    return party_ids.includes(party_id);
+}
+export const parties_by_party_id = {
+    DEM: {
+        party_id: "DEM",
+        name: "Democratic Party",
+        adjective: "Democratic"
+    },
+    REP: {
+        party_id: "REP",
+        name: "Republican Party",
+        adjective: "Republican"
+    },
+    ETC: {
+        party_id: "ETC",
+        name: "Other Party",
+        adjective: "Third-Party"
+    },
+    NON: {
+        party_id: "NON",
+        name: "Nonpartisan",
+        adjective: "Nonpartisan"
+    }
+};