scout-types 1.0.0

package/dist/src/types/OfficeClass.js

@@ -0,0 +1,132 @@
+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",
+        jurisdiction_level: JurisdictionLevel.SCHOOL,
+        jurisdictions_mutable: true,
+        require_district: true,
+        require_initial_jurisdiction: true,
+        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",
+            "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",
+        jurisdiction_level: JurisdictionLevel.SCHOOL,
+        jurisdictions_mutable: true,
+        require_district: false,
+        require_initial_jurisdiction: true,
+        office_names: [
+            "Board Member"
+        ]
+    }
+};

package/dist/src/types/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/types/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"
+    }
+};

package/dist/src/types/Scout.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 Scout {
+    readonly office_id: string;
+    readonly number: string;
+    readonly scout_id: string;
+    readonly name: string;
+    readonly active: boolean;
+    readonly state_id: StateID;
+    readonly district?: number;
+    readonly party_id: PartyID;
+    readonly tone_description_refresh: boolean;
+    readonly jurisdiction_ids: number[];
+    readonly office_class_id: OfficeClassID;
+    readonly office_name?: string;
+    readonly [x: string]: any;
+    constructor(scout: any);
+    static is(scout: any): scout is Scout;
+}
+export declare class ScoutAux extends Scout {
+    readonly jurisdictions: Jurisdiction[];
+    readonly photo_download_url?: string;
+    readonly tone_description?: string;
+    constructor(scout: any);
+    static is(scout: any): scout is ScoutAux;
+}

package/dist/src/types/Scout.js

@@ -0,0 +1,72 @@
+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 Scout {
+    office_id;
+    number;
+    scout_id;
+    name;
+    active;
+    state_id;
+    district;
+    party_id;
+    tone_description_refresh;
+    jurisdiction_ids;
+    office_class_id;
+    office_name;
+    constructor(scout) {
+        if (!Scout.is(scout)) {
+            throw Error("Invalid input.");
+        }
+        this.office_id = scout.office_id;
+        this.number = scout.number;
+        this.scout_id = scout.scout_id;
+        this.name = scout.name;
+        this.active = scout.active;
+        this.state_id = scout.state_id;
+        this.district = scout.district;
+        this.party_id = scout.party_id;
+        this.tone_description_refresh = scout.tone_description_refresh;
+        this.jurisdiction_ids = scout.jurisdiction_ids;
+        this.office_class_id = scout.office_class_id;
+        this.office_name = scout.office_name;
+    }
+    static is(scout) {
+        return (scout !== undefined &&
+            typeof scout.office_id === "string" &&
+            typeof scout.number === "string" &&
+            typeof scout.scout_id === "string" &&
+            typeof scout.name === "string" &&
+            typeof scout.active === "boolean" &&
+            is_state_id(scout.state_id) &&
+            (scout.district === undefined || typeof scout.district === "number") &&
+            is_party_id(scout.party_id) &&
+            typeof scout.tone_description_refresh === "boolean" &&
+            Array.isArray(scout.jurisdiction_ids) &&
+            scout.jurisdiction_ids.every((jurisdiction_id) => typeof jurisdiction_id === "number") &&
+            is_office_class_id(scout.office_class_id) &&
+            (scout.office_name === undefined || typeof scout.office_name === "string"));
+    }
+}
+export class ScoutAux extends Scout {
+    jurisdictions;
+    photo_download_url;
+    tone_description;
+    constructor(scout) {
+        if (!ScoutAux.is(scout)) {
+            throw Error("Invalid input.");
+        }
+        super(scout);
+        this.jurisdictions = scout.jurisdictions;
+        this.photo_download_url = scout.photo_download_url;
+        this.tone_description = scout.tone_description;
+    }
+    static is(scout) {
+        return (Scout.is(scout) &&
+            Array.isArray(scout.jurisdictions) &&
+            scout.jurisdictions.every(Jurisdiction.is) &&
+            (scout.photo_download_url === undefined || typeof scout.photo_download_url === "string") &&
+            (scout.tone_description === undefined || typeof scout.tone_description === "string"));
+    }
+}

package/dist/src/types/ScoutConfig.d.ts

@@ -0,0 +1,27 @@
+export interface ScoutUtilsConfig {
+    region: string;
+    scraping_bee_api_key?: string;
+    xai_api_key?: string;
+    citizenportal_api_key?: string;
+    [key: string]: any;
+}
+export interface ScoutConfig extends ScoutUtilsConfig {
+    port: number;
+    api_url: string;
+    client_url: string;
+    auth_url: string;
+    cognito_user_pool_id: string;
+    cognito_client_id: string;
+    cognito_client_secret: string;
+    secret_key: string;
+    admin_key: string;
+    dynamodb_scouts: string;
+    dynamodb_scout_documents: string;
+    dynamodb_conversations: string;
+    dynamodb_jurisdictions: string;
+    dynamodb_jurisdiction_documents: string;
+    dynamodb_messages: string;
+    dynamodb_users: string;
+    s3_bucket: string;
+    s3vectors_bucket: string;
+}

package/dist/src/types/ScoutConfig.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/ScoutDocument.d.ts

@@ -0,0 +1,14 @@
+import { Tweet } from "./Tweet.js";
+export declare class ScoutDocument {
+    readonly scout_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(scout_document: any);
+    static is(scout_document: any): scout_document is ScoutDocument;
+}

package/dist/src/types/ScoutDocument.js

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

package/dist/src/types/Sources.d.ts

@@ -0,0 +1,50 @@
+import { ScoutDocument } from "./ScoutDocument.js";
+import { JurisdictionDocument } from "./JurisdictionDocument.js";
+import { Bill } from "./Bill.js";
+export declare class ScoutDocumentSource {
+    readonly chunk_text: string;
+    readonly description: string;
+    readonly label: string;
+    readonly type: string;
+    readonly vector_key: string;
+    readonly document: ScoutDocument;
+    constructor(scout_document_source: any);
+    static is(scout_document_source: any): scout_document_source is ScoutDocumentSource;
+}
+export declare 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);
+    static is(jurisdiction_document_source: any): jurisdiction_document_source is JurisdictionDocumentSource;
+}
+export declare class BillDocumentSource {
+    readonly chunk_text: string;
+    readonly description: string;
+    readonly label: string;
+    readonly type: string;
+    readonly vector_key: string;
+    readonly bill: Bill;
+    constructor(bill_document_source: any);
+    static is(bill_document_source: any): bill_document_source is BillDocumentSource;
+}
+export declare class GrokSource {
+    readonly title: string;
+    readonly url: string;
+    readonly start_index: number;
+    readonly end_index: number;
+    readonly type: string;
+    constructor(grok_source: any);
+    static is(grok_source: any): grok_source is GrokSource;
+}
+export declare class Sources {
+    readonly B: BillDocumentSource[];
+    readonly S: ScoutDocumentSource[];
+    readonly J: JurisdictionDocumentSource[];
+    readonly G: GrokSource[];
+    constructor(sources: any);
+    static is(sources: any): sources is Sources;
+}

package/dist/src/types/Sources.js

@@ -0,0 +1,138 @@
+import { ScoutDocument } from "./ScoutDocument.js";
+import { JurisdictionDocument } from "./JurisdictionDocument.js";
+import { Bill } from "./Bill.js";
+export class ScoutDocumentSource {
+    chunk_text;
+    description;
+    label;
+    type;
+    vector_key;
+    document;
+    constructor(scout_document_source) {
+        if (!ScoutDocumentSource.is(scout_document_source)) {
+            throw Error("Invalid input.");
+        }
+        this.chunk_text = scout_document_source.chunk_text;
+        this.description = scout_document_source.description;
+        this.label = scout_document_source.label;
+        this.type = scout_document_source.type;
+        this.vector_key = scout_document_source.vector_key;
+        this.document = scout_document_source.document;
+    }
+    static is(scout_document_source) {
+        return (scout_document_source !== undefined &&
+            typeof scout_document_source.chunk_text === "string" &&
+            typeof scout_document_source.description === "string" &&
+            typeof scout_document_source.label === "string" &&
+            typeof scout_document_source.type === "string" &&
+            typeof scout_document_source.vector_key === "string" &&
+            ScoutDocument.is(scout_document_source.document));
+    }
+}
+export class JurisdictionDocumentSource {
+    chunk_text;
+    description;
+    label;
+    type;
+    vector_key;
+    document;
+    constructor(jurisdiction_document_source) {
+        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) {
+        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 BillDocumentSource {
+    chunk_text;
+    description;
+    label;
+    type;
+    vector_key;
+    bill;
+    constructor(bill_document_source) {
+        if (!BillDocumentSource.is(bill_document_source)) {
+            throw Error("Invalid input.");
+        }
+        this.chunk_text = bill_document_source.chunk_text;
+        this.description = bill_document_source.description;
+        this.label = bill_document_source.label;
+        this.type = bill_document_source.type;
+        this.vector_key = bill_document_source.vector_key;
+        this.bill = bill_document_source.bill;
+    }
+    static is(bill_document_source) {
+        return (bill_document_source !== undefined &&
+            typeof bill_document_source.chunk_text === "string" &&
+            typeof bill_document_source.description === "string" &&
+            typeof bill_document_source.label === "string" &&
+            typeof bill_document_source.type === "string" &&
+            typeof bill_document_source.vector_key === "string" &&
+            Bill.is(bill_document_source.bill));
+    }
+}
+export class GrokSource {
+    title;
+    url;
+    start_index;
+    end_index;
+    type;
+    constructor(grok_source) {
+        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) {
+        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 {
+    B;
+    S;
+    J;
+    G;
+    constructor(sources) {
+        if (!Sources.is(sources)) {
+            throw Error("Invalid input.");
+        }
+        this.B = sources.B;
+        this.S = sources.S;
+        this.J = sources.J;
+        this.G = sources.G;
+    }
+    static is(sources) {
+        return (sources !== undefined &&
+            Array.isArray(sources.B) &&
+            sources.B.every(BillDocumentSource.is) &&
+            Array.isArray(sources.S) &&
+            sources.S.every(ScoutDocumentSource.is) &&
+            Array.isArray(sources.J) &&
+            sources.J.every(JurisdictionDocumentSource.is) &&
+            Array.isArray(sources.G) &&
+            sources.G.every(GrokSource.is));
+    }
+}

package/dist/src/types/State.d.ts

@@ -0,0 +1,11 @@
+declare const state_ids: readonly ["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"];
+export type StateID = typeof state_ids[number];
+export declare function is_state_id(state_id: any): state_id is StateID;
+export interface State {
+    state_id: StateID;
+    name: string;
+    jurisdiction_id: number;
+    schools_jurisdiction_id: number;
+}
+export declare const states_by_state_id: Record<StateID, State>;
+export {};