doers-comms-types 1.0.0

package/eslint.config.ts

@@ -0,0 +1,13 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import { defineConfig } from "eslint/config";
+
+export default defineConfig([
+    { files: ["**/*.{js,mjs,cjs,ts,mts,cts}"], plugins: { js }, extends: ["js/recommended"], languageOptions: { globals: globals.browser } },
+    {
+		rules: {
+            "@typescript-eslint/explicit-function-return-type": "error"
+		},
+	},
+]);

package/jest.config.js

@@ -0,0 +1,20 @@
+import { createDefaultPreset } from "ts-jest"
+
+const tsJestTransformCfg = createDefaultPreset().transform;
+
+/** @type {import("jest").Config} **/
+export default {
+    testEnvironment: "node",
+    transform: {
+        ...tsJestTransformCfg,
+    },
+    transformIgnorePatterns: ["/node_modules/(?!@smithy|@aws-sdk).+\\.js$"],
+    globals : {
+        "ts-jest" : {
+            useESM : true
+        }
+    },
+    extensionsToTreatAsEsm : [".ts"],
+    testTimeout : 30000,
+    testPathIgnorePatterns: ['dist/']
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+    "name": "doers-comms-types",
+    "version": "1.0.0",
+    "main": "dist/src/index.js",
+    "types": "dist/src/index.d.ts",
+    "directories": {
+        "test": "test"
+    },
+    "scripts": {
+        "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+        "build": "tsc && tsc-alias"
+    },
+    "author": "",
+    "license": "ISC",
+    "description": "",
+    "type": "module",
+    "dependencies": {
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.39.2",
+        "@types/jest": "^30.0.0",
+        "eslint": "^9.39.2",
+        "globals": "^17.3.0",
+        "jest": "^30.2.0",
+        "jiti": "^2.6.1",
+        "ts-jest": "^29.4.6",
+        "tsc-alias": "^1.8.16",
+        "tsx": "^4.21.0",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.55.0"
+    }
+}

package/src/Bot.ts

@@ -0,0 +1,84 @@
+import { is_office_class_id, OfficeClassID } from "./OfficeClass"
+import { Jurisdiction } from "./Jurisdiction"
+import { is_state_id, StateID } from "./State"
+import { is_party_id, PartyID } from "./Party"
+
+export 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) {
+        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 : any) : bot 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 : any) => typeof topic === "string") &&
+            Array.isArray(bot.jurisdiction_ids) &&
+            bot.jurisdiction_ids.every((jurisdiction_id : any) => 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 {
+    readonly jurisdictions : Jurisdiction[]
+    readonly photo_download_url? : string
+
+    constructor(bot : any) {
+        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 : any) : bot is BotAux {
+        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/src/BotDocument.ts

@@ -0,0 +1,43 @@
+import { Tweet } from "./Tweet"
+
+export 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) {
+        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 : any) : bot_document is BotDocument {
+        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 : any) => typeof vector_key === "string")) &&
+            (bot_document.tweet === undefined || Tweet.is(bot_document.tweet)) &&
+            (bot_document.text === undefined || typeof bot_document.text === "string")
+        )
+    }
+}

package/src/Conversation.ts

@@ -0,0 +1,53 @@
+import { Message } from "./Message"
+
+export 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) {
+        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 : any) : conversation 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 : any) => typeof topic === "string"))
+        )
+    }
+}
+
+export class ConversationAux extends Conversation {
+    readonly messages : Message[]
+
+    constructor(conversation : any) {
+        if (!ConversationAux.is(conversation)) {
+            throw Error("Invalid input.")
+        }
+        super(conversation)
+        this.messages = conversation.messages
+    }
+
+    static is(conversation : any) : conversation is ConversationAux {
+        return (
+            Conversation.is(conversation) &&
+            Array.isArray(conversation.messages) &&
+            conversation.messages.every(Message.is)
+        )
+    }
+}

package/src/DoersAPIError.ts

@@ -0,0 +1,20 @@
+const default_messages_by_status : Record<number, string> = {
+    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 : number
+    constructor(status : number, message?: string) {
+        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/src/DoersCommsUtilsConfig.ts

@@ -0,0 +1,7 @@
+export interface DoersCommsUtilsConfig {
+    region : string,
+    scraping_bee_api_key? : string,
+    xai_api_key? : string,
+    citizenportal_api_key? : string,
+    [key : string]: any
+}

package/src/Jurisdiction.ts

@@ -0,0 +1,58 @@
+export enum JurisdictionLevel {
+    SCHOOL = 0,
+    NATION = 1,
+    STATE = 2,
+    COUNTY = 3,
+    CITY = 4
+}
+
+export function is_jurisdiction_level(jurisdiction_level : any) : jurisdiction_level is JurisdictionLevel {
+    return [0, 1, 2, 3, 4].includes(jurisdiction_level)
+}
+
+export 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) {
+        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 : any) : jurisdiction is Jurisdiction {
+        return (
+            jurisdiction !== undefined &&
+            typeof jurisdiction.jurisdiction_id === "number" &&
+            typeof jurisdiction.name === "string" &&
+            Array.isArray(jurisdiction.path) &&
+            jurisdiction.path.every((jurisdiction_id : any) => typeof jurisdiction_id === "number") &&
+            Array.isArray(jurisdiction.sub_jurisdiction_ids) &&
+            jurisdiction.sub_jurisdiction_ids.every((jurisdiction_id : any) => 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/src/JurisdictionDocument.ts

@@ -0,0 +1,48 @@
+export 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) {
+        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 : any) : jurisdiction_document is JurisdictionDocument {
+        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 : any) => typeof vector_key === "string") &&
+            (jurisdiction_document.location === undefined || typeof jurisdiction_document.location === "string")
+        )
+    }
+}

package/src/Message.ts

@@ -0,0 +1,94 @@
+import { Sources } from "./Sources"
+
+export class Fragment {
+    readonly text : string
+    readonly sources : Sources
+
+    constructor(fragment : any) {
+        if (!Fragment.is(fragment)) {
+            throw Error("Invalid input.")
+        }
+        this.text = fragment.text
+        this.sources = fragment.sources
+    }
+
+    static is(fragment : any) : fragment is Fragment {
+        return (
+            fragment !== undefined &&
+            typeof fragment.text === "string" &&
+            Sources.is(fragment.sources)
+        )
+    }
+}
+
+export class Post {
+    text : string
+    s3_image_filename? : string
+    s3_image_url? : string
+
+    constructor(post : any) {
+        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 : any) : post 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 {
+    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) {
+        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 : any) : message 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/src/OfficeClass.ts

@@ -0,0 +1,149 @@
+import { JurisdictionLevel } from "./Jurisdiction"
+
+const office_class_ids = ["ORG", "USH", "USS", "STG", "STH", "STS", "STB", "COG", "CIG", "LOB"] as const
+
+export type OfficeClassID = typeof office_class_ids[number]
+
+export function is_office_class_id(office_class_id : any) : office_class_id is OfficeClassID {
+    return office_class_ids.includes(office_class_id)
+}
+
+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 const office_classes_by_office_class_id : Record<OfficeClassID, OfficeClass> = {
+    "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/src/Party.ts

@@ -0,0 +1,36 @@
+const party_ids = ["DEM", "REP", "NON", "ETC"] as const
+
+export type PartyID = typeof party_ids[number]
+
+export function is_party_id(party_id : any) : party_id is PartyID {
+    return party_ids.includes(party_id)
+}
+
+export interface Party {
+    party_id : PartyID,
+    name : string,
+    adjective : string
+}
+
+export const parties_by_party_id : Record<PartyID, Party> = {
+    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"
+    }
+}

package/src/Sources.ts

@@ -0,0 +1,125 @@
+import { BotDocument } from "./BotDocument"
+import { JurisdictionDocument } from "./JurisdictionDocument"
+
+export class BotDocumentSource {
+    readonly chunk_text : string
+    readonly description : string
+    readonly label : string
+    readonly type : string
+    readonly vector_key : string
+    readonly document : BotDocument
+
+    constructor(bot_document_source : any) {
+        if (!BotDocumentSource.is(bot_document_source)) {
+            throw Error("Invalid input.")
+        }
+        this.chunk_text = bot_document_source.chunk_text
+        this.description = bot_document_source.description
+        this.label = bot_document_source.label
+        this.type = bot_document_source.type
+        this.vector_key = bot_document_source.vector_key
+        this.document = bot_document_source.document
+    }
+
+    static is(bot_document_source : any) : bot_document_source is BotDocumentSource {
+        return (
+            bot_document_source !== undefined &&
+            typeof bot_document_source.chunk_text === "string" &&
+            typeof bot_document_source.description === "string" &&
+            typeof bot_document_source.label === "string" &&
+            typeof bot_document_source.type === "string" &&
+            typeof bot_document_source.vector_key === "string" &&
+            BotDocument.is(bot_document_source.document)
+        )
+    }
+}
+
+export class JurisdictionDocumentSource {
+    readonly chunk_text : string
+    readonly description : string
+    readonly label : string
+    readonly type : string
+    readonly vector_key : string
+    readonly document : JurisdictionDocument
+
+    constructor(jurisdiction_document_source : any) {
+        if (!JurisdictionDocumentSource.is(jurisdiction_document_source)) {
+            throw Error("Invalid input.")
+        }
+        this.chunk_text = jurisdiction_document_source.chunk_text
+        this.description = jurisdiction_document_source.description
+        this.label = jurisdiction_document_source.label
+        this.type = jurisdiction_document_source.type
+        this.vector_key = jurisdiction_document_source.vector_key
+        this.document = jurisdiction_document_source.document
+    }
+
+    static is(jurisdiction_document_source : any) : jurisdiction_document_source is JurisdictionDocumentSource {
+        return (
+            jurisdiction_document_source !== undefined &&
+            typeof jurisdiction_document_source.chunk_text === "string" &&
+            typeof jurisdiction_document_source.description === "string" &&
+            typeof jurisdiction_document_source.label === "string" &&
+            typeof jurisdiction_document_source.type === "string" &&
+            typeof jurisdiction_document_source.vector_key === "string" &&
+            JurisdictionDocument.is(jurisdiction_document_source.document)
+        )
+    }
+}
+
+export class GrokSource {
+    readonly title : string
+    readonly url : string
+    readonly start_index : number
+    readonly end_index : number
+    readonly type : string
+
+    constructor(grok_source : any) {
+        if (!GrokSource.is(grok_source)) {
+            throw Error("Invalid input.")
+        }
+        this.title = grok_source.title
+        this.url = grok_source.url
+        this.start_index = grok_source.start_index
+        this.end_index = grok_source.end_index
+        this.type = grok_source.type
+    }
+
+    static is(grok_source : any) : grok_source is GrokSource {
+        return (
+            grok_source !== undefined &&
+            typeof grok_source.title === "string" &&
+            typeof grok_source.url === "string" &&
+            typeof grok_source.start_index === "number" &&
+            typeof grok_source.end_index === "number" &&
+            typeof grok_source.type === "string"
+        )
+    }
+}
+
+export class Sources {
+    readonly B : BotDocumentSource[]
+    readonly J : JurisdictionDocumentSource[]
+    readonly G : GrokSource[]
+
+    constructor(sources : any) {
+        if (!Sources.is(sources)) {
+            throw Error("Invalid input.")
+        }
+        this.B = sources.B
+        this.J = sources.J
+        this.G = sources.G
+    }
+
+    static is(sources : any) : sources is Sources {
+        return (
+            sources !== undefined &&
+            Array.isArray(sources.B) &&
+            sources.B.every(BotDocumentSource.is) &&
+            Array.isArray(sources.J) &&
+            sources.J.every(JurisdictionDocumentSource.is) &&
+            Array.isArray(sources.G) &&
+            sources.G.every(GrokSource.is)
+        )
+    }
+}

package/src/State.ts

@@ -0,0 +1,266 @@
+const state_ids = ["AL", "AK", "AZ", "AR", "CA", "CO", "CT", "DE", "FL", "GA", "HI", "ID", "IL", "IN", "IA", "KS", "KY", "LA", "ME", "MD", "MA", "MI", "MN", "MS", "MO", "MT", "NE", "NV", "NH", "NJ", "NM", "NY", "NC", "ND", "OH", "OK", "OR", "PA", "RI", "SC", "SD", "TN", "TX", "UT", "VT", "VA", "WA", "WV", "WI", "WY"] as const
+
+export type StateID = typeof state_ids[number]
+
+export function is_state_id(state_id : any) : state_id is StateID {
+    return state_ids.includes(state_id)
+}
+
+export interface State {
+    state_id : StateID,
+    name : string,
+    jurisdiction_id : number
+}
+
+export const states_by_state_id : Record<StateID, State> = {
+    AL : {
+        state_id : "AL",
+        name : "Alabama",
+        jurisdiction_id : 2280
+    },
+    AK : {
+        state_id : "AK",
+        name : "Alaska",
+        jurisdiction_id : 2281
+    },
+    AZ : {
+        state_id : "AZ",
+        name : "Arizona",
+        jurisdiction_id : 2148
+    },
+    AR : {
+        state_id : "AR",
+        name : "Arkansas",
+        jurisdiction_id : 2282
+    },
+    CA : {
+        state_id : "CA",
+        name : "California",
+        jurisdiction_id : 2283
+    },
+    CO : {
+        state_id : "CO",
+        name : "Colorado",
+        jurisdiction_id : 2284
+    },
+    CT : {
+        state_id : "CT",
+        name : "Connecticut",
+        jurisdiction_id : 2314
+    },
+    DE : {
+        state_id : "DE",
+        name : "Delaware",
+        jurisdiction_id : 2315
+    },
+    FL : {
+        state_id : "FL",
+        name : "Florida",
+        jurisdiction_id : 2316
+    },
+    GA : {
+        state_id : "GA",
+        name : "Georgia",
+        jurisdiction_id : 2317
+    },
+    HI : {
+        state_id : "HI",
+        name : "Hawaii",
+        jurisdiction_id : 2156
+    },
+    ID : {
+        state_id : "ID",
+        name : "Idaho",
+        jurisdiction_id : 2318
+    },
+    IL : {
+        state_id : "IL",
+        name : "Illinois",
+        jurisdiction_id : 2319
+    },
+    IN : {
+        state_id : "IN",
+        name : "Indiana",
+        jurisdiction_id : 2159
+    },
+    IA : {
+        state_id : "IA",
+        name : "Iowa",
+        jurisdiction_id : 2320
+    },
+    KS : {
+        state_id : "KS",
+        name : "Kansas",
+        jurisdiction_id : 2161
+    },
+    KY : {
+        state_id : "KY",
+        name : "Kentucky",
+        jurisdiction_id : 2162
+    },
+    LA : {
+        state_id : "LA",
+        name : "Louisiana",
+        jurisdiction_id : 2163
+    },
+    ME : {
+        state_id : "ME",
+        name : "Maine",
+        jurisdiction_id : 2164
+    },
+    MD : {
+        state_id : "MD",
+        name : "Maryland",
+        jurisdiction_id : 2165
+    },
+    MA : {
+        state_id : "MA",
+        name : "Massachusetts",
+        jurisdiction_id : 2166
+    },
+    MI : {
+        state_id : "MI",
+        name : "Michigan",
+        jurisdiction_id : 2167
+    },
+    MN : {
+        state_id : "MN",
+        name : "Minnesota",
+        jurisdiction_id : 2286
+    },
+    MS : {
+        state_id : "MS",
+        name : "Mississippi",
+        jurisdiction_id : 2287
+    },
+    MO : {
+        state_id : "MO",
+        name : "Missouri",
+        jurisdiction_id : 2288
+    },
+    MT : {
+        state_id : "MT",
+        name : "Montana",
+        jurisdiction_id : 2289
+    },
+    NE : {
+        state_id : "NE",
+        name : "Nebraska",
+        jurisdiction_id : 2290
+    },
+    NV : {
+        state_id : "NV",
+        name : "Nevada",
+        jurisdiction_id : 2291
+    },
+    NH : {
+        state_id : "NH",
+        name : "New Hampshire",
+        jurisdiction_id : 2292
+    },
+    NJ : {
+        state_id : "NJ",
+        name : "New Jersey",
+        jurisdiction_id : 2293
+    },
+    NM : {
+        state_id : "NM",
+        name : "New Mexico",
+        jurisdiction_id : 2294
+    },
+    NY : {
+        state_id : "NY",
+        name : "New York",
+        jurisdiction_id : 2295
+    },
+    NC : {
+        state_id : "NC",
+        name : "North Carolina",
+        jurisdiction_id : 2296
+    },
+    ND : {
+        state_id : "ND",
+        name : "North Dakota",
+        jurisdiction_id : 2297
+    },
+    OH : {
+        state_id : "OH",
+        name : "Ohio",
+        jurisdiction_id : 2298
+    },
+    OK : {
+        state_id : "OK",
+        name : "Oklahoma",
+        jurisdiction_id : 2299
+    },
+    OR : {
+        state_id : "OR",
+        name : "Oregon",
+        jurisdiction_id : 2300
+    },
+    PA : {
+        state_id : "PA",
+        name : "Pennsylvania",
+        jurisdiction_id : 2301
+    },
+    RI : {
+        state_id : "RI",
+        name : "Rhode Island",
+        jurisdiction_id : 2302
+    },
+    SC : {
+        state_id : "SC",
+        name : "South Carolina",
+        jurisdiction_id : 2303
+    },
+    SD : {
+        state_id : "SD",
+        name : "South Dakota",
+        jurisdiction_id : 2304
+    },
+    TN : {
+        state_id : "TN",
+        name : "Tennessee",
+        jurisdiction_id : 2305
+    },
+    TX : {
+        state_id : "TX",
+        name : "Texas",
+        jurisdiction_id : 2306
+    },
+    UT : {
+        state_id : "UT",
+        name : "Utah",
+        jurisdiction_id : 2307
+    },
+    VT : {
+        state_id : "VT",
+        name : "Vermont",
+        jurisdiction_id : 2308
+    },
+    VA : {
+        state_id : "VA",
+        name : "Virginia",
+        jurisdiction_id : 2309
+    },
+    WA : {
+        state_id : "WA",
+        name : "Washington",
+        jurisdiction_id : 2310
+    },
+    WV : {
+        state_id : "WV",
+        name : "West Virginia",
+        jurisdiction_id : 2311
+    },
+    WI : {
+        state_id : "WI",
+        name : "Wisconsin",
+        jurisdiction_id : 2312
+    },
+    WY : {
+        state_id : "WY",
+        name : "Wyoming",
+        jurisdiction_id : 2313
+    }
+}

package/src/Tweet.ts

@@ -0,0 +1,36 @@
+export class Tweet {
+    readonly tweet_id : string
+    readonly username : string
+    readonly url : string
+    readonly tweet_time : string
+    readonly tweet_content : string
+    readonly replying_to : string[]
+    readonly quote? : string
+
+    constructor(tweet : any) {
+        if (!Tweet.is(tweet)) {
+            throw Error("Invalid input.")
+        }
+        this.tweet_id = tweet.tweet_id
+        this.username = tweet.username
+        this.url = tweet.url
+        this.tweet_time = tweet.tweet_time
+        this.tweet_content = tweet.tweet_content
+        this.replying_to = tweet.replying_to
+        this.quote = tweet.quote
+    }
+
+    static is(tweet : any) : tweet is Tweet {
+        return (
+            tweet !== undefined &&
+            typeof tweet.tweet_id === "string" &&
+            typeof tweet.username === "string" &&
+            typeof tweet.url === "string" &&
+            typeof tweet.tweet_time === "string" &&
+            typeof tweet.tweet_content === "string" &&
+            Array.isArray(tweet.replying_to) &&
+            tweet.replying_to.every((username : any) => typeof username === "string") &&
+            (tweet.quote === undefined || typeof tweet.quote === "string")
+        )
+    }
+}

package/src/User.ts

@@ -0,0 +1,50 @@
+import { BotAux } from "./Bot"
+
+export class User {
+    readonly user_id : string
+    readonly admin : boolean
+    readonly bot_ids : string[]
+    readonly email : string
+    readonly [x : string] : any
+
+    constructor(user : any) {
+        if (!User.is(user)) {
+            throw Error("Invalid Input.")
+        }
+        this.user_id = user.user_id
+        this.admin = user.admin
+        this.bot_ids = user.bot_ids
+        this.email = user.email
+    }
+
+    static is(user : any) : user is User {
+        return (
+            user !== undefined &&
+            typeof user.user_id === "string" &&
+            typeof user.admin === "boolean" &&
+            typeof user.email === "string" &&
+            Array.isArray(user.bot_ids) &&
+            user.bot_ids.every((bot_id : any) => typeof bot_id === "string")
+        )
+    }
+}
+
+export class UserAux extends User {
+    readonly bots : BotAux[]
+
+    constructor(user : any) {
+        if (!UserAux.is(user)) {
+            throw Error("Invalid Input.")
+        }
+        super(user)
+        this.bots = user.bots
+    }
+
+    static is(user : any) : user is UserAux {
+        return (
+            User.is(user) &&
+            Array.isArray(user.bots) &&
+            user.bots.every(BotAux.is)
+        )
+    }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+export * from "./Bot"
+export * from "./BotDocument"
+export * from "./Conversation"
+export * from "./DoersAPIError"
+export * from "./DoersCommsUtilsConfig"
+export * from "./Jurisdiction"
+export * from "./JurisdictionDocument"
+export * from "./Message"
+export * from "./OfficeClass"
+export * from "./Party"
+export * from "./Sources"
+export * from "./State"
+export * from "./User"

package/tsconfig.json

@@ -0,0 +1,34 @@
+{
+	"compilerOptions": {
+        "outDir": "./dist",
+
+		// Treat files as modules even if it doesn't use import/export
+		"moduleDetection": "force",
+
+		// Ignore module structure
+		"module" : "esnext",
+        "target" : "es2022",
+        "noImplicitAny" : true,
+        "noImplicitReturns" : true,
+        "moduleResolution": "node",
+        "declaration": true,
+		// Allow JS files to be imported from TS and vice versa
+		"allowJs": true,
+        "strict" : true,
+		// Use correct ESM import behavior
+		"esModuleInterop": true,
+        "resolveJsonModule": true,
+		// Disallow features that require cross-file awareness
+		"isolatedModules": true,
+    	"lib": ["es2022"],
+        "rootDir": "./",
+        "skipLibCheck": true,
+        "maxNodeModuleJsDepth": 0,
+        "types": ["jest", "node"]
+	},
+    "tsc-alias": {
+        "resolveFullPaths": true,
+        "verbose": false
+    },
+    "include" : ["src/**/*", "test/**/*"]
+}