triangle-types 1.0.0

package/dist/src/types/federal_dockets/FederalDocketComment.js

@@ -0,0 +1,86 @@
+export class Commentor {
+    first_name;
+    last_name;
+    organization_name;
+    address_1;
+    address_2;
+    city;
+    state_id;
+    zip;
+    country;
+    email;
+    phone;
+    constructor(commentor) {
+        if (!Commentor.is(commentor)) {
+            throw Error("Invalid input.");
+        }
+        this.first_name = commentor.first_name;
+        this.last_name = commentor.last_name;
+        this.organization_name = commentor.organization_name;
+        this.address_1 = commentor.address_1;
+        this.address_2 = commentor.address_2;
+        this.city = commentor.city;
+        this.state_id = commentor.state_id;
+        this.zip = commentor.zip;
+        this.country = commentor.country;
+        this.email = commentor.email;
+        this.phone = commentor.phone;
+    }
+    static is(commentor) {
+        return (commentor !== undefined &&
+            (commentor.first_name === undefined || typeof commentor.first_name === "string") &&
+            (commentor.last_name === undefined || typeof commentor.last_name === "string") &&
+            (commentor.organization_name === undefined || typeof commentor.organization_name === "string") &&
+            (commentor.address_1 === undefined || typeof commentor.address_1 === "string") &&
+            (commentor.address_2 === undefined || typeof commentor.address_2 === "string") &&
+            (commentor.city === undefined || typeof commentor.city === "string") &&
+            (commentor.state_id === undefined || typeof commentor.state_id === "string") &&
+            (commentor.zip === undefined || typeof commentor.zip === "string") &&
+            (commentor.country === undefined || typeof commentor.country === "string") &&
+            (commentor.email === undefined || typeof commentor.email === "string") &&
+            (commentor.phone === undefined || typeof commentor.phone === "string"));
+    }
+}
+export class FederalDocketComment {
+    federal_docket_comment_id;
+    federal_docket_agency_id;
+    federal_docket_id;
+    federal_docket_document_id;
+    title;
+    publish_time;
+    comment_time;
+    modify_time;
+    is_withdrawn;
+    commentor;
+    text;
+    constructor(federal_docket_comment) {
+        if (!FederalDocketComment.is(federal_docket_comment)) {
+            throw Error("Invalid input.");
+        }
+        this.federal_docket_comment_id = federal_docket_comment.federal_docket_comment_id;
+        this.federal_docket_agency_id = federal_docket_comment.federal_docket_agency_id;
+        this.federal_docket_id = federal_docket_comment.federal_docket_id;
+        this.federal_docket_document_id = federal_docket_comment.federal_docket_document_id;
+        this.title = federal_docket_comment.title;
+        this.publish_time = federal_docket_comment.publish_time;
+        this.comment_time = federal_docket_comment.comment_time;
+        this.modify_time = federal_docket_comment.modify_time;
+        this.is_withdrawn = federal_docket_comment.is_withdrawn;
+        this.commentor = new Commentor(federal_docket_comment.commentor);
+        this.text = federal_docket_comment.text;
+    }
+    static is(federal_docket_comment) {
+        return (federal_docket_comment !== undefined &&
+            typeof federal_docket_comment.federal_docket_comment_id === "string" &&
+            typeof federal_docket_comment.federal_docket_agency_id === "string" &&
+            typeof federal_docket_comment.federal_docket_id === "string" &&
+            (federal_docket_comment.federal_docket_document_id === undefined || typeof federal_docket_comment.federal_docket_document_id === "string") &&
+            typeof federal_docket_comment.title === "string" &&
+            (federal_docket_comment.publish_time === undefined || typeof federal_docket_comment.publish_time === "string") &&
+            (federal_docket_comment.comment_time === undefined || typeof federal_docket_comment.comment_time === "string") &&
+            typeof federal_docket_comment.modify_time === "string" &&
+            typeof federal_docket_comment.is_withdrawn === "boolean" &&
+            Commentor.is(federal_docket_comment.commentor) &&
+            typeof federal_docket_comment.text === "string");
+    }
+}

package/dist/src/types/federal_dockets/FederalDocketCommentAttachment.d.ts

@@ -0,0 +1,9 @@
+export declare class FederalDocketCommentAttachment {
+    readonly federal_docket_comment_attachment_id: string;
+    readonly federal_docket_comment_id: string;
+    readonly attachment_number: number;
+    readonly urls: string[];
+    readonly s3_ids?: string[];
+    constructor(federal_docket_comment_attachment: any);
+    static is(federal_docket_comment_attachment: any): federal_docket_comment_attachment is FederalDocketCommentAttachment;
+}

package/dist/src/types/federal_dockets/FederalDocketCommentAttachment.js

@@ -0,0 +1,25 @@
+export class FederalDocketCommentAttachment {
+    federal_docket_comment_attachment_id;
+    federal_docket_comment_id;
+    attachment_number;
+    urls;
+    s3_ids;
+    constructor(federal_docket_comment_attachment) {
+        if (!FederalDocketCommentAttachment.is(federal_docket_comment_attachment)) {
+            throw Error("Invalid input.");
+        }
+        this.federal_docket_comment_attachment_id = federal_docket_comment_attachment.federal_docket_comment_attachment_id;
+        this.attachment_number = federal_docket_comment_attachment.attachment_number;
+        this.federal_docket_comment_id = federal_docket_comment_attachment.federal_docket_comment_id;
+        this.urls = federal_docket_comment_attachment.urls;
+        this.s3_ids = federal_docket_comment_attachment.s3_ids;
+    }
+    static is(federal_docket_comment_attachment) {
+        return (federal_docket_comment_attachment !== undefined &&
+            typeof federal_docket_comment_attachment.federal_docket_comment_attachment_id === "string" &&
+            typeof federal_docket_comment_attachment.federal_docket_comment_id === "string" &&
+            typeof federal_docket_comment_attachment.attachment_number === "number" &&
+            Array.isArray(federal_docket_comment_attachment.urls) && federal_docket_comment_attachment.urls.every((url) => typeof url === "string") &&
+            (federal_docket_comment_attachment.s3_ids === undefined || Array.isArray(federal_docket_comment_attachment.s3_ids) && federal_docket_comment_attachment.s3_ids.every((s3_id) => typeof s3_id === "string")));
+    }
+}

package/dist/src/types/federal_dockets/FederalDocketDocument.d.ts

@@ -0,0 +1,27 @@
+export declare const federal_docket_document_type_ids: readonly ["N", "P", "R", "S", "O"];
+export type FederalDocketDocumentTypeID = typeof federal_docket_document_type_ids[number];
+export declare function is_federal_docket_document_type_id(federal_docket_document_type_id: any): federal_docket_document_type_id is FederalDocketDocumentTypeID;
+export declare class FederalDocketDocument {
+    readonly federal_docket_document_id: string;
+    readonly federal_docket_agency_id: string;
+    readonly federal_docket_id?: string;
+    readonly type_id: FederalDocketDocumentTypeID;
+    readonly subtype_id?: string;
+    readonly federal_register_document_id?: string;
+    readonly title: string;
+    readonly publish_time?: string;
+    readonly modify_time: string;
+    readonly comment_start_time?: string;
+    readonly comment_end_time?: string;
+    readonly comments_open: boolean;
+    readonly comments_late_allow: boolean;
+    readonly is_withdrawn: boolean;
+    readonly author_date?: string;
+    readonly author_names: string[];
+    readonly media_type_id?: string;
+    readonly abstract?: string;
+    readonly urls: string[];
+    readonly s3_ids?: string[];
+    constructor(federal_docket_document: any);
+    static is(federal_docket_document: any): federal_docket_document is FederalDocketDocument;
+}

package/dist/src/types/federal_dockets/FederalDocketDocument.js

@@ -0,0 +1,74 @@
+export const federal_docket_document_type_ids = ["N", "P", "R", "S", "O"];
+export function is_federal_docket_document_type_id(federal_docket_document_type_id) {
+    return federal_docket_document_type_ids.includes(federal_docket_document_type_id);
+}
+export class FederalDocketDocument {
+    federal_docket_document_id;
+    federal_docket_agency_id;
+    federal_docket_id;
+    type_id;
+    subtype_id;
+    federal_register_document_id;
+    title;
+    publish_time;
+    modify_time;
+    comment_start_time;
+    comment_end_time;
+    comments_open;
+    comments_late_allow;
+    is_withdrawn;
+    author_date;
+    author_names;
+    media_type_id;
+    abstract;
+    urls;
+    s3_ids;
+    constructor(federal_docket_document) {
+        if (!FederalDocketDocument.is(federal_docket_document)) {
+            throw Error("Invalid input.");
+        }
+        this.federal_docket_document_id = federal_docket_document.federal_docket_document_id;
+        this.federal_docket_agency_id = federal_docket_document.federal_docket_agency_id;
+        this.federal_docket_id = federal_docket_document.federal_docket_id;
+        this.type_id = federal_docket_document.type_id;
+        this.subtype_id = federal_docket_document.subtype_id;
+        this.federal_register_document_id = federal_docket_document.federal_register_document_id;
+        this.title = federal_docket_document.title;
+        this.publish_time = federal_docket_document.publish_time;
+        this.modify_time = federal_docket_document.modify_time;
+        this.comment_start_time = federal_docket_document.comment_start_time;
+        this.comment_end_time = federal_docket_document.comment_end_time;
+        this.comments_open = federal_docket_document.comments_open;
+        this.comments_late_allow = federal_docket_document.comments_late_allow;
+        this.is_withdrawn = federal_docket_document.is_withdrawn;
+        this.author_date = federal_docket_document.author_date;
+        this.author_names = federal_docket_document.author_names;
+        this.media_type_id = federal_docket_document.media_type_id;
+        this.abstract = federal_docket_document.abstract;
+        this.urls = federal_docket_document.urls;
+        this.s3_ids = federal_docket_document.s3_ids;
+    }
+    static is(federal_docket_document) {
+        return (federal_docket_document !== undefined &&
+            typeof federal_docket_document.federal_docket_document_id === "string" &&
+            typeof federal_docket_document.federal_docket_agency_id === "string" &&
+            (federal_docket_document.federal_docket_id === undefined || typeof federal_docket_document.federal_docket_id === "string") &&
+            is_federal_docket_document_type_id(federal_docket_document.type_id) &&
+            (federal_docket_document.subtype_id === undefined || typeof federal_docket_document.subtype_id === "string") &&
+            (federal_docket_document.federal_register_document_id === undefined || typeof federal_docket_document.federal_register_document_id === "string") &&
+            typeof federal_docket_document.title === "string" &&
+            (federal_docket_document.publish_time === undefined || typeof federal_docket_document.publish_time === "string") &&
+            typeof federal_docket_document.modify_time === "string" &&
+            (federal_docket_document.comment_start_time === undefined || typeof federal_docket_document.comment_start_time === "string") &&
+            (federal_docket_document.comment_end_time === undefined || typeof federal_docket_document.comment_end_time === "string") &&
+            typeof federal_docket_document.comments_open === "boolean" &&
+            typeof federal_docket_document.comments_late_allow === "boolean" &&
+            typeof federal_docket_document.is_withdrawn === "boolean" &&
+            (federal_docket_document.author_date === undefined || typeof federal_docket_document.author_date === "string") &&
+            Array.isArray(federal_docket_document.author_names) && federal_docket_document.author_names.every((author_name) => typeof author_name === "string") &&
+            (federal_docket_document.media_type_id === undefined || typeof federal_docket_document.media_type_id === "string") &&
+            (federal_docket_document.abstract === undefined || typeof federal_docket_document.abstract === "string") &&
+            Array.isArray(federal_docket_document.urls) && federal_docket_document.urls.every((url) => typeof url === "string") &&
+            (federal_docket_document.s3_ids === undefined || Array.isArray(federal_docket_document.s3_ids) && federal_docket_document.s3_ids.every((s3_id) => typeof s3_id === "string")));
+    }
+}

package/dist/src/types/federal_elections/FederalElection.d.ts

@@ -0,0 +1,27 @@
+import { FederalElectionCandidateAux } from "./FederalElectionCandidate.js";
+import { FederalElectionCommitteeAux } from "./FederalElectionCommittee.js";
+import { FederalElectionFileExpenditureAux } from "./FederalElectionFileExpenditure.js";
+import { StateID } from "../State.js";
+declare const federal_election_office_ids: readonly ["H", "S", "P"];
+export type FederalElectionOfficeID = typeof federal_election_office_ids[number];
+export declare function is_federal_election_office_id(federal_election_office_id: any): federal_election_office_id is FederalElectionOfficeID;
+export type FederalElectionID = string;
+export declare function is_federal_election_id(federal_election_id: any): federal_election_id is FederalElectionID;
+export declare class FederalElection {
+    readonly federal_election_id: FederalElectionID;
+    readonly name: string;
+    readonly federal_election_office_id: FederalElectionOfficeID;
+    readonly state_id?: StateID;
+    readonly district?: number;
+    readonly [x: string]: any;
+    constructor(federal_election: FederalElection);
+    static is(federal_election: any): federal_election is FederalElection;
+}
+export declare class FederalElectionAux extends FederalElection {
+    readonly federal_election_candidates: FederalElectionCandidateAux[];
+    readonly federal_election_committees: FederalElectionCommitteeAux[];
+    readonly federal_election_file_expenditures: FederalElectionFileExpenditureAux[];
+    constructor(federal_election: any);
+    static is(federal_election: any): federal_election is FederalElectionAux;
+}
+export {};

package/dist/src/types/federal_elections/FederalElection.js

@@ -0,0 +1,86 @@
+import { FederalElectionCandidateAux } from "./FederalElectionCandidate.js";
+import { FederalElectionCommitteeAux } from "./FederalElectionCommittee.js";
+import { FederalElectionFileExpenditureAux } from "./FederalElectionFileExpenditure.js";
+import { is_state_id } from "../State.js";
+const federal_election_office_ids = ["H", "S", "P"];
+export function is_federal_election_office_id(federal_election_office_id) {
+    return federal_election_office_ids.includes(federal_election_office_id);
+}
+const state_ids_without_district = ["AK", "DE", "ND", "SD", "VT", "WY"];
+export function is_federal_election_id(federal_election_id) {
+    const parts = federal_election_id.split("-");
+    const year = Number(parts[0]);
+    const federal_election_office_id = parts[1];
+    const state_id = parts[2];
+    const district = Number(parts[3]);
+    if (!(Number.isInteger(year) && year > 1700 && year < 3000 && is_federal_election_office_id(federal_election_office_id))) {
+        return false;
+    }
+    if (federal_election_office_id === "P" && parts.length === 2) {
+        return true;
+    }
+    if (!is_state_id(state_id)) {
+        return false;
+    }
+    if (federal_election_office_id === "S" && parts.length === 3) {
+        return true;
+    }
+    if (federal_election_office_id !== "H") {
+        return false;
+    }
+    if (!(state_ids_without_district.includes(state_id) && parts.length === 3 || parts.length === 4)) {
+        return false;
+    }
+    if (!Number.isInteger(district) && district < 100) {
+        return false;
+    }
+    return true;
+}
+export class FederalElection {
+    federal_election_id;
+    name;
+    federal_election_office_id;
+    state_id;
+    district;
+    constructor(federal_election) {
+        if (!FederalElection.is(federal_election)) {
+            throw Error("Invalid input.");
+        }
+        this.federal_election_id = federal_election.federal_election_id;
+        this.name = federal_election.name;
+        this.federal_election_office_id = federal_election.federal_election_office_id;
+        this.state_id = federal_election.state_id;
+        this.district = federal_election.district;
+    }
+    static is(federal_election) {
+        return (federal_election !== undefined &&
+            is_federal_election_id(federal_election.federal_election_id) &&
+            typeof federal_election.name === "string" &&
+            is_federal_election_office_id(federal_election.federal_election_office_id) &&
+            (federal_election.state_id === undefined || is_state_id(federal_election.state_id)) &&
+            (federal_election.district === undefined || typeof federal_election.district === "number"));
+    }
+}
+export class FederalElectionAux extends FederalElection {
+    federal_election_candidates;
+    federal_election_committees;
+    federal_election_file_expenditures;
+    constructor(federal_election) {
+        if (!FederalElectionAux.is(federal_election)) {
+            throw Error("Invalid input.");
+        }
+        super(federal_election);
+        this.federal_election_candidates = federal_election.federal_election_candidates;
+        this.federal_election_committees = federal_election.federal_election_committees;
+        this.federal_election_file_expenditures = federal_election.federal_election_file_expenditures;
+    }
+    static is(federal_election) {
+        return (FederalElection.is(federal_election) &&
+            Array.isArray(federal_election.federal_election_candidates) &&
+            federal_election.federal_election_candidates.every(FederalElectionCandidateAux.is) &&
+            Array.isArray(federal_election.federal_election_committees) &&
+            federal_election.federal_election_committees.every(FederalElectionCommitteeAux.is) &&
+            Array.isArray(federal_election.federal_election_file_expenditures) &&
+            federal_election.federal_election_file_expenditures.every(FederalElectionFileExpenditureAux.is));
+    }
+}

package/dist/src/types/federal_elections/FederalElectionCandidate.d.ts

@@ -0,0 +1,40 @@
+import { FederalElectionCommitteeAux } from "./FederalElectionCommittee.js";
+import { FederalElectionID, FederalElectionOfficeID } from "./FederalElection.js";
+import { FederalElectionFileExpenditureAux } from "./FederalElectionFileExpenditure.js";
+import { FederalElectionF3File } from "./FederalElectionF3File.js";
+import { StateID } from "../State.js";
+export declare class ActivityIndex {
+    readonly news_index: number;
+    readonly twitter_index: number;
+    readonly total_index: number;
+    constructor(activity_index: any);
+    static is(activity_index: any): activity_index is ActivityIndex;
+}
+export declare class FederalElectionCandidate {
+    readonly federal_election_candidate_id: string;
+    readonly name: string;
+    readonly federal_election_office_id: FederalElectionOfficeID;
+    readonly state_id: StateID;
+    readonly district?: number;
+    readonly federal_election_id: FederalElectionID;
+    readonly party_id?: string;
+    readonly is_active?: boolean;
+    readonly status?: string;
+    readonly federal_election_file_id?: number;
+    readonly ballotpedia_name?: string;
+    readonly ballotpedia_url?: string;
+    readonly ballotpedia_data?: Record<string, any>;
+    readonly activity_index?: ActivityIndex;
+    readonly is_veteran?: string;
+    readonly url_veteran?: string;
+    [x: string]: any;
+    constructor(federal_election_candidate: FederalElectionCandidate);
+    static is(federal_election_candidate: any): federal_election_candidate is FederalElectionCandidate;
+}
+export declare class FederalElectionCandidateAux extends FederalElectionCandidate {
+    readonly federal_election_committees: FederalElectionCommitteeAux[];
+    readonly federal_election_f3_files: FederalElectionF3File[];
+    readonly federal_election_file_expenditures: FederalElectionFileExpenditureAux[];
+    constructor(federal_election_candidate: any);
+    static is(federal_election_candidate: any): federal_election_candidate is FederalElectionCandidateAux;
+}

package/dist/src/types/federal_elections/FederalElectionCandidate.js

@@ -0,0 +1,105 @@
+import { FederalElectionCommitteeAux } from "./FederalElectionCommittee.js";
+import { is_federal_election_id, is_federal_election_office_id } from "./FederalElection.js";
+import { FederalElectionFileExpenditureAux } from "./FederalElectionFileExpenditure.js";
+import { FederalElectionF3File } from "./FederalElectionF3File.js";
+import { is_state_id } from "../State.js";
+export class ActivityIndex {
+    news_index;
+    twitter_index;
+    total_index;
+    constructor(activity_index) {
+        if (!ActivityIndex.is(activity_index)) {
+            throw Error("Invalid input.");
+        }
+        this.news_index = activity_index.news_index;
+        this.twitter_index = activity_index.twitter_index;
+        this.total_index = activity_index.total_index;
+    }
+    static is(activity_index) {
+        return (activity_index !== undefined &&
+            typeof activity_index.news_index === "number" &&
+            typeof activity_index.twitter_index === "number" &&
+            typeof activity_index.total_index === "number");
+    }
+}
+export class FederalElectionCandidate {
+    federal_election_candidate_id;
+    name;
+    federal_election_office_id;
+    state_id;
+    district;
+    federal_election_id;
+    party_id;
+    is_active;
+    status;
+    federal_election_file_id;
+    ballotpedia_name;
+    ballotpedia_url;
+    ballotpedia_data;
+    activity_index;
+    is_veteran;
+    url_veteran;
+    constructor(federal_election_candidate) {
+        if (!FederalElectionCandidate.is(federal_election_candidate)) {
+            throw Error("Invalid input.");
+        }
+        this.federal_election_candidate_id = federal_election_candidate.federal_election_candidate_id;
+        this.name = federal_election_candidate.name;
+        this.federal_election_office_id = federal_election_candidate.federal_election_office_id;
+        this.state_id = federal_election_candidate.state_id;
+        this.district = federal_election_candidate.district;
+        this.federal_election_id = federal_election_candidate.federal_election_id;
+        this.party_id = federal_election_candidate.party_id;
+        this.is_active = federal_election_candidate.is_active;
+        this.status = federal_election_candidate.status;
+        this.federal_election_file_id = federal_election_candidate.federal_election_file_id;
+        this.ballotpedia_name = federal_election_candidate.ballotpedia_name;
+        this.ballotpedia_url = federal_election_candidate.ballotpedia_url;
+        this.ballotpedia_data = federal_election_candidate.ballotpedia_data;
+        this.activity_index = federal_election_candidate.activity_index;
+        this.is_veteran = federal_election_candidate.is_veteran;
+        this.url_veteran = federal_election_candidate.url_veteran;
+    }
+    static is(federal_election_candidate) {
+        return (federal_election_candidate !== undefined &&
+            typeof federal_election_candidate.federal_election_candidate_id === "string" &&
+            typeof federal_election_candidate.name === "string" &&
+            is_federal_election_office_id(federal_election_candidate.federal_election_office_id) &&
+            is_state_id(federal_election_candidate.state_id) &&
+            (federal_election_candidate.district === undefined || typeof federal_election_candidate.district === "number") &&
+            is_federal_election_id(federal_election_candidate.federal_election_id) &&
+            (federal_election_candidate.party_id === undefined || typeof federal_election_candidate.party_id === "string") &&
+            (federal_election_candidate.is_active === undefined || typeof federal_election_candidate.is_active === "boolean") &&
+            (federal_election_candidate.status === undefined || typeof federal_election_candidate.status === "string") &&
+            (federal_election_candidate.federal_election_file_id === undefined || typeof federal_election_candidate.federal_election_file_id === "number" && !isNaN(federal_election_candidate.federal_election_file_id)) &&
+            (federal_election_candidate.ballotpedia_name === undefined || typeof federal_election_candidate.ballotpedia_name === "string") &&
+            (federal_election_candidate.ballotpedia_url === undefined || typeof federal_election_candidate.ballotpedia_url === "string") &&
+            (federal_election_candidate.ballotpedia_data === undefined || typeof federal_election_candidate.ballotpedia_data === "object" && Object.keys(federal_election_candidate.ballotpedia_data).map((key) => typeof key === "string")) &&
+            (federal_election_candidate.activity_index === undefined || ActivityIndex.is(federal_election_candidate.activity_index)) &&
+            (federal_election_candidate.is_veteran === undefined || typeof federal_election_candidate.is_veteran === "string") &&
+            (federal_election_candidate.url_veteran === undefined || typeof federal_election_candidate.url_veteran === "string"));
+    }
+}
+export class FederalElectionCandidateAux extends FederalElectionCandidate {
+    federal_election_committees;
+    federal_election_f3_files;
+    federal_election_file_expenditures;
+    constructor(federal_election_candidate) {
+        if (!FederalElectionCandidateAux.is(federal_election_candidate)) {
+            throw Error("Invalid input.");
+        }
+        super(federal_election_candidate);
+        this.federal_election_committees = federal_election_candidate.federal_election_committees;
+        this.federal_election_f3_files = federal_election_candidate.federal_election_f3_files;
+        this.federal_election_file_expenditures = federal_election_candidate.federal_election_file_expenditures;
+    }
+    static is(federal_election_candidate) {
+        return (FederalElectionCandidate.is(federal_election_candidate) &&
+            Array.isArray(federal_election_candidate.federal_election_committees) &&
+            federal_election_candidate.federal_election_committees.every(FederalElectionCommitteeAux.is) &&
+            Array.isArray(federal_election_candidate.federal_election_f3_files) &&
+            federal_election_candidate.federal_election_f3_files.every(FederalElectionF3File.is) &&
+            Array.isArray(federal_election_candidate.federal_election_file_expenditures) &&
+            federal_election_candidate.federal_election_file_expenditures.every(FederalElectionFileExpenditureAux.is));
+    }
+}

package/dist/src/types/federal_elections/FederalElectionCandidateCommittee.d.ts

@@ -0,0 +1,7 @@
+export declare class FederalElectionCandidateCommittee {
+    readonly federal_election_candidate_id: string;
+    readonly federal_election_committee_id: string;
+    [x: string]: any;
+    constructor(federal_election_candidate_committee: FederalElectionCandidateCommittee);
+    static is(federal_election_candidate_committee: any): federal_election_candidate_committee is FederalElectionCandidateCommittee;
+}

package/dist/src/types/federal_elections/FederalElectionCandidateCommittee.js

@@ -0,0 +1,32 @@
+export class FederalElectionCandidateCommittee {
+    federal_election_candidate_id;
+    federal_election_committee_id;
+    constructor(federal_election_candidate_committee) {
+        if (!FederalElectionCandidateCommittee.is(federal_election_candidate_committee)) {
+            throw Error("Invalid input.");
+        }
+        this.federal_election_candidate_id = federal_election_candidate_committee.federal_election_candidate_id;
+        this.federal_election_committee_id = federal_election_candidate_committee.federal_election_committee_id;
+    }
+    static is(federal_election_candidate_committee) {
+        return (federal_election_candidate_committee !== undefined &&
+            typeof federal_election_candidate_committee.federal_election_candidate_id === "string" &&
+            typeof federal_election_candidate_committee.federal_election_committee_id === "string");
+    }
+}
+// export class CandidateCommitteeAux extends CandidateCommittee {
+//     readonly committee : FederalElectionCommitteeAux
+//     constructor(candidate_committee : any) {
+//         if (!CandidateCommitteeAux.is(candidate_committee)) {
+//             throw Error("Invalid input.")
+//         }
+//         super(candidate_committee)
+//         this.committee = candidate_committee.committee
+//     }
+//     static is(candidate_committee : any) : candidate_committee is CandidateCommitteeAux {
+//         return (
+//             CandidateCommittee.is(candidate_committee) &&
+//             FederalElectionCommitteeAux.is(candidate_committee.committee)
+//         )
+//     }
+// }

package/dist/src/types/federal_elections/FederalElectionCommittee.d.ts

@@ -0,0 +1,27 @@
+import { FederalElectionCandidate } from "./FederalElectionCandidate.js";
+import { FederalElectionF3File } from "./FederalElectionF3File.js";
+export declare const designations: readonly ["P", "A", "U", "J", "D", "B"];
+export type FederalElectionCommitteeDesignation = typeof designations[number];
+export declare function is_federal_election_committee_designation(designation: any): designation is FederalElectionCommitteeDesignation;
+export declare class FederalElectionCommittee {
+    readonly federal_election_committee_id: string;
+    readonly name: string;
+    readonly url?: string;
+    readonly designation?: FederalElectionCommitteeDesignation;
+    readonly federal_election_file_id?: number;
+    readonly jfp_federal_election_committee_ids?: string[];
+    readonly jfr_federal_election_committee_ids: string[];
+    readonly aff_federal_election_committee_ids: string[];
+    readonly [x: string]: any;
+    constructor(federal_election_committee: FederalElectionCommittee);
+    static is(federal_election_committee: any): federal_election_committee is FederalElectionCommittee;
+}
+export declare class FederalElectionCommitteeAux extends FederalElectionCommittee {
+    readonly federal_election_candidates: FederalElectionCandidate[];
+    readonly federal_election_f3_files: FederalElectionF3File[];
+    readonly jfp_federal_election_committees?: FederalElectionCommittee[];
+    readonly jfr_federal_election_committees: FederalElectionCommittee[];
+    readonly aff_federal_election_committees: FederalElectionCommittee[];
+    constructor(federal_election_committee: any);
+    static is(federal_election_committee: any): federal_election_committee is FederalElectionCommitteeAux;
+}

package/dist/src/types/federal_elections/FederalElectionCommittee.js

@@ -0,0 +1,68 @@
+import { FederalElectionCandidate } from "./FederalElectionCandidate.js";
+import { FederalElectionF3File } from "./FederalElectionF3File.js";
+export const designations = ["P", "A", "U", "J", "D", "B"];
+export function is_federal_election_committee_designation(designation) {
+    return designations.includes(designation);
+}
+export class FederalElectionCommittee {
+    federal_election_committee_id;
+    name;
+    url;
+    designation;
+    federal_election_file_id;
+    jfp_federal_election_committee_ids;
+    jfr_federal_election_committee_ids;
+    aff_federal_election_committee_ids;
+    constructor(federal_election_committee) {
+        if (!FederalElectionCommittee.is(federal_election_committee)) {
+            throw Error("Invalid input.");
+        }
+        this.federal_election_committee_id = federal_election_committee.federal_election_committee_id;
+        this.name = federal_election_committee.name;
+        this.url = federal_election_committee.url;
+        this.designation = federal_election_committee.designation;
+        this.federal_election_file_id = federal_election_committee.federal_election_file_id;
+        this.jfp_federal_election_committee_ids = federal_election_committee.jfp_federal_election_committee_ids;
+        this.jfr_federal_election_committee_ids = federal_election_committee.jfr_federal_election_committee_ids;
+        this.aff_federal_election_committee_ids = federal_election_committee.aff_federal_election_committee_ids;
+    }
+    static is(federal_election_committee) {
+        return (federal_election_committee !== undefined &&
+            typeof federal_election_committee.federal_election_committee_id === "string" &&
+            typeof federal_election_committee.name === "string" &&
+            (federal_election_committee.url === undefined || typeof federal_election_committee.url === "string") &&
+            (federal_election_committee.designation === undefined || is_federal_election_committee_designation(federal_election_committee.designation)) &&
+            (federal_election_committee.federal_election_file_id === undefined || typeof federal_election_committee.federal_election_file_id === "number" && !isNaN(federal_election_committee.federal_election_file_id)) &&
+            (federal_election_committee.jfp_federal_election_committee_ids === undefined || Array.isArray(federal_election_committee.jfp_federal_election_committee_ids) && federal_election_committee.jfp_federal_election_committee_ids.every((federal_election_committee_id) => typeof federal_election_committee_id === "string")) &&
+            (Array.isArray(federal_election_committee.jfr_federal_election_committee_ids) && federal_election_committee.jfr_federal_election_committee_ids.every((federal_election_committee_id) => typeof federal_election_committee_id === "string")) &&
+            (Array.isArray(federal_election_committee.aff_federal_election_committee_ids) && federal_election_committee.aff_federal_election_committee_ids.every((federal_election_committee_id) => typeof federal_election_committee_id === "string")));
+    }
+}
+export class FederalElectionCommitteeAux extends FederalElectionCommittee {
+    federal_election_candidates;
+    federal_election_f3_files;
+    jfp_federal_election_committees;
+    jfr_federal_election_committees;
+    aff_federal_election_committees;
+    constructor(federal_election_committee) {
+        if (!FederalElectionCommitteeAux.is(federal_election_committee)) {
+            throw Error("Invalid input.");
+        }
+        super(federal_election_committee);
+        this.federal_election_candidates = federal_election_committee.federal_election_candidates;
+        this.federal_election_f3_files = federal_election_committee.federal_election_f3_files;
+        this.jfp_federal_election_committees = federal_election_committee.jfp_federal_election_committees;
+        this.jfr_federal_election_committees = federal_election_committee.jfr_federal_election_committees;
+        this.aff_federal_election_committees = federal_election_committee.aff_federal_election_committees;
+    }
+    static is(federal_election_committee) {
+        return (FederalElectionCommittee.is(federal_election_committee) &&
+            Array.isArray(federal_election_committee.federal_election_candidates) &&
+            federal_election_committee.federal_election_candidates.every(FederalElectionCandidate.is) &&
+            Array.isArray(federal_election_committee.federal_election_f3_files) &&
+            federal_election_committee.federal_election_f3_files.every(FederalElectionF3File.is) &&
+            (federal_election_committee.jfp_federal_election_committees === undefined || Array.isArray(federal_election_committee.jfp_federal_election_committees) && federal_election_committee.jfp_federal_election_committees.every(FederalElectionCommittee.is)) &&
+            (Array.isArray(federal_election_committee.jfr_federal_election_committees) && federal_election_committee.jfr_federal_election_committees.every(FederalElectionCommittee.is)) &&
+            (Array.isArray(federal_election_committee.aff_federal_election_committees) && federal_election_committee.aff_federal_election_committees.every(FederalElectionCommittee.is)));
+    }
+}