triangle-types 1.0.0

package/dist/src/types/state_permits/StatePermitDocument.js

@@ -0,0 +1,95 @@
+import { is_state_id } from "../State.js";
+import { StatePermitDocumentSourceAux } from "./StatePermitDocumentSource.js";
+export class StatePermitComment {
+    comment_text;
+    response_text;
+    constructor(state_permit_comment) {
+        if (!StatePermitComment.is(state_permit_comment)) {
+            throw Error("Invalid input.");
+        }
+        this.comment_text = state_permit_comment.comment_text;
+        this.response_text = state_permit_comment.response_text;
+    }
+    static is(state_permit_comment) {
+        return (state_permit_comment !== undefined &&
+            typeof state_permit_comment.comment_text === "string" &&
+            typeof state_permit_comment.response_text === "string");
+    }
+}
+export class StatePermitDocument {
+    state_permit_document_id;
+    state_id;
+    state_permit_id;
+    document_id;
+    permit_type_id;
+    document_type;
+    document_type_id;
+    name;
+    s3_id;
+    s3_id_txt;
+    source_ids;
+    comments;
+    constructor(state_permit_document) {
+        if (!StatePermitDocument.is(state_permit_document)) {
+            throw Error("Invalid input.");
+        }
+        this.state_permit_document_id = state_permit_document.state_permit_document_id;
+        this.state_id = state_permit_document.state_id;
+        this.state_permit_id = state_permit_document.state_permit_id;
+        this.document_id = state_permit_document.document_id;
+        this.permit_type_id = state_permit_document.permit_type_id;
+        this.document_type = state_permit_document.document_type;
+        this.document_type_id = state_permit_document.document_type_id;
+        this.name = state_permit_document.name;
+        this.s3_id = state_permit_document.s3_id;
+        this.s3_id_txt = state_permit_document.s3_id_txt;
+        this.source_ids = state_permit_document.source_ids;
+        this.comments = state_permit_document.comments;
+    }
+    static is(state_permit_document) {
+        return (state_permit_document !== undefined &&
+            typeof state_permit_document.state_permit_document_id === "string" &&
+            is_state_id(state_permit_document.state_id) &&
+            typeof state_permit_document.state_permit_id === "string" &&
+            typeof state_permit_document.document_id === "string" &&
+            typeof state_permit_document.permit_type_id === "string" &&
+            typeof state_permit_document.document_type === "string" &&
+            (state_permit_document.document_type_id === undefined || typeof state_permit_document.document_type_id === "string") &&
+            typeof state_permit_document.name === "string" &&
+            (state_permit_document.s3_id === undefined || typeof state_permit_document.s3_id == "string") &&
+            (state_permit_document.s3_id_txt === undefined || typeof state_permit_document.s3_id_txt == "string") &&
+            (state_permit_document.source_ids === undefined || Array.isArray(state_permit_document.source_ids) && state_permit_document.source_ids.every((source_id) => typeof source_id === "string")) &&
+            (state_permit_document.comments === undefined || Array.isArray(state_permit_document.comments) && state_permit_document.comments.every(StatePermitComment.is)));
+    }
+}
+export class StateWaterPermitDocument extends StatePermitDocument {
+    permit_type_id;
+    freq_fish_tissue;
+    constructor(state_permit_document) {
+        if (!StateWaterPermitDocument.is(state_permit_document)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit_document);
+        this.permit_type_id = state_permit_document.permit_type_id;
+        this.freq_fish_tissue = state_permit_document.freq_fish_tissue;
+    }
+    static is(state_permit_document) {
+        return (StatePermitDocument.is(state_permit_document) &&
+            state_permit_document.permit_type_id === "WATER-NPDES" &&
+            (state_permit_document.freq_fish_tissue === undefined || typeof state_permit_document.freq_fish_tissue === "string"));
+    }
+}
+export class StatePermitDocumentAux extends StatePermitDocument {
+    sources;
+    constructor(state_permit_document) {
+        if (!StatePermitDocumentAux.is(state_permit_document)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit_document);
+        this.sources = state_permit_document.sources;
+    }
+    static is(state_permit_document) {
+        return (StatePermitDocument.is(state_permit_document) &&
+            Array.isArray(state_permit_document.sources) && state_permit_document.sources.every(StatePermitDocumentSourceAux.is));
+    }
+}

package/dist/src/types/state_permits/StatePermitDocumentSource.d.ts

@@ -0,0 +1,48 @@
+import { StateID } from "../State.js";
+import { StatePermitAux } from "./StatePermit.js";
+import { StatePermitDocument } from "./StatePermitDocument.js";
+import { StatePermitDocumentSourcePollutant } from "./StatePermitDocumentSourcePollutant.js";
+export declare class StatePermitDocumentSource {
+    readonly state_permit_document_source_id: string;
+    readonly state_id: StateID;
+    readonly state_permit_id: string;
+    readonly state_permit_document_id: string;
+    readonly source_id: string;
+    readonly permit_type_id: string;
+    readonly source_type_id: string;
+    readonly description: string;
+    readonly pollutant_ids?: string[];
+    readonly [x: string]: any;
+    constructor(state_permit_document_source: StatePermitDocumentSource);
+    static is(state_permit_document_source: any): state_permit_document_source is StatePermitDocumentSource;
+}
+export declare class StateWaterPermitDocumentSource extends StatePermitDocumentSource {
+    readonly permit_type_id: "WATER-NPDES";
+    readonly freq_wet_pp?: string;
+    readonly freq_wet_cd?: string;
+    readonly [x: string]: any;
+    constructor(state_permit_document_source: StateWaterPermitDocumentSource);
+    static is(state_permit_document_source: any): state_permit_document_source is StateWaterPermitDocumentSource;
+}
+export declare class StateAirPermitDocumentSource extends StatePermitDocumentSource {
+    readonly permit_type_id: "AIR";
+    readonly page_nums: number[];
+    readonly is_rice?: string;
+    readonly power_quantity?: number;
+    readonly power_unit?: string;
+    readonly power_kw?: number;
+    readonly fuel_type_text?: string;
+    readonly fuel_type_id?: string;
+    readonly is_emergency?: string;
+    readonly local_state_permit_document_source_ids?: string[];
+    readonly [x: string]: any;
+    constructor(state_permit_document_source: StateAirPermitDocumentSource);
+    static is(state_permit_document_source: any): state_permit_document_source is StateAirPermitDocumentSource;
+}
+export declare class StatePermitDocumentSourceAux extends StatePermitDocumentSource {
+    readonly state_permit: StatePermitAux;
+    readonly state_permit_document: StatePermitDocument;
+    readonly pollutants: StatePermitDocumentSourcePollutant[];
+    constructor(state_permit_document_source: StatePermitDocumentSourceAux);
+    static is(state_permit_document_source: any): state_permit_document_source is StatePermitDocumentSourceAux;
+}

package/dist/src/types/state_permits/StatePermitDocumentSource.js

@@ -0,0 +1,123 @@
+import { is_state_id } from "../State.js";
+import { StatePermitAux } from "./StatePermit.js";
+import { StatePermitDocument } from "./StatePermitDocument.js";
+import { StatePermitDocumentSourcePollutant } from "./StatePermitDocumentSourcePollutant.js";
+export class StatePermitDocumentSource {
+    state_permit_document_source_id;
+    state_id;
+    state_permit_id;
+    state_permit_document_id;
+    source_id;
+    permit_type_id;
+    source_type_id;
+    description;
+    pollutant_ids;
+    constructor(state_permit_document_source) {
+        if (!StatePermitDocumentSource.is(state_permit_document_source)) {
+            throw Error("Invalid input.");
+        }
+        this.state_permit_document_source_id = state_permit_document_source.state_permit_document_source_id;
+        this.state_id = state_permit_document_source.state_id;
+        this.state_permit_id = state_permit_document_source.state_permit_id;
+        this.state_permit_document_id = state_permit_document_source.state_permit_document_id;
+        this.source_id = state_permit_document_source.source_id;
+        this.permit_type_id = state_permit_document_source.permit_type_id;
+        this.source_type_id = state_permit_document_source.source_type_id;
+        this.description = state_permit_document_source.description;
+        this.pollutant_ids = state_permit_document_source.pollutant_ids;
+    }
+    static is(state_permit_document_source) {
+        return (state_permit_document_source !== undefined &&
+            typeof state_permit_document_source.state_permit_document_source_id === "string" &&
+            is_state_id(state_permit_document_source.state_id) &&
+            typeof state_permit_document_source.state_permit_id === "string" &&
+            typeof state_permit_document_source.state_permit_document_id === "string" &&
+            typeof state_permit_document_source.source_id === "string" &&
+            typeof state_permit_document_source.permit_type_id === "string" &&
+            typeof state_permit_document_source.source_type_id === "string" &&
+            typeof state_permit_document_source.description === "string" &&
+            (state_permit_document_source.pollutant_ids === undefined || Array.isArray(state_permit_document_source.pollutant_ids) && state_permit_document_source.pollutant_ids.every((pollutant_id) => typeof pollutant_id === "string")));
+    }
+}
+export class StateWaterPermitDocumentSource extends StatePermitDocumentSource {
+    permit_type_id;
+    freq_wet_pp;
+    freq_wet_cd;
+    constructor(state_permit_document_source) {
+        if (!StateWaterPermitDocumentSource.is(state_permit_document_source)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit_document_source);
+        this.permit_type_id = state_permit_document_source.permit_type_id;
+        this.freq_wet_pp = state_permit_document_source.freq_wet_pp;
+        this.freq_wet_cd = state_permit_document_source.freq_wet_cd;
+    }
+    static is(state_permit_document_source) {
+        return (StatePermitDocumentSource.is(state_permit_document_source) &&
+            state_permit_document_source.permit_type_id === "WATER-NPDES" &&
+            (state_permit_document_source.freq_wet_pp === undefined || typeof state_permit_document_source.freq_wet_pp === "string") &&
+            (state_permit_document_source.freq_wet_cd === undefined || typeof state_permit_document_source.freq_wet_cd === "string"));
+    }
+}
+export class StateAirPermitDocumentSource extends StatePermitDocumentSource {
+    permit_type_id;
+    page_nums;
+    is_rice;
+    power_quantity;
+    power_unit;
+    power_kw;
+    fuel_type_text;
+    fuel_type_id;
+    is_emergency;
+    local_state_permit_document_source_ids;
+    constructor(state_permit_document_source) {
+        if (!StateAirPermitDocumentSource.is(state_permit_document_source)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit_document_source);
+        this.permit_type_id = state_permit_document_source.permit_type_id;
+        this.page_nums = state_permit_document_source.page_nums;
+        this.is_rice = state_permit_document_source.is_rice;
+        this.power_quantity = state_permit_document_source.power_quantity;
+        this.power_unit = state_permit_document_source.power_unit;
+        this.power_kw = state_permit_document_source.power_kw;
+        this.fuel_type_text = state_permit_document_source.fuel_type_text;
+        this.fuel_type_id = state_permit_document_source.fuel_type_id;
+        this.is_emergency = state_permit_document_source.is_emergency;
+        this.local_state_permit_document_source_ids = state_permit_document_source.local_state_permit_document_source_ids;
+    }
+    static is(state_permit_document_source) {
+        return (StatePermitDocumentSource.is(state_permit_document_source) &&
+            state_permit_document_source.permit_type_id === "AIR" &&
+            Array.isArray(state_permit_document_source.page_nums) && state_permit_document_source.page_nums.every((page_num) => typeof page_num === "number") &&
+            (state_permit_document_source.is_rice === undefined || typeof state_permit_document_source.is_rice === "string") &&
+            (state_permit_document_source.power_quantity === undefined || typeof state_permit_document_source.power_quantity === "number") &&
+            (state_permit_document_source.power_quantity === undefined || typeof state_permit_document_source.power_quantity === "number") &&
+            (state_permit_document_source.power_kw === undefined || typeof state_permit_document_source.power_kw === "number") &&
+            (state_permit_document_source.fuel_type_text === undefined || typeof state_permit_document_source.fuel_type_text === "string") &&
+            (state_permit_document_source.fuel_type_id === undefined || typeof state_permit_document_source.fuel_type_id === "string") &&
+            (state_permit_document_source.is_emergency === undefined || typeof state_permit_document_source.is_emergency === "string") &&
+            (state_permit_document_source.local_state_permit_document_source_ids === undefined || Array.isArray(state_permit_document_source.local_state_permit_document_source_ids) && state_permit_document_source.local_state_permit_document_source_ids.every((local_state_permit_document_source_id) => typeof local_state_permit_document_source_id === "string")));
+    }
+}
+export class StatePermitDocumentSourceAux extends StatePermitDocumentSource {
+    state_permit;
+    state_permit_document;
+    pollutants;
+    constructor(state_permit_document_source) {
+        if (!StatePermitDocumentSourceAux.is(state_permit_document_source)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit_document_source);
+        this.state_permit = state_permit_document_source.state_permit;
+        this.state_permit_document = state_permit_document_source.state_permit_document;
+        this.pollutants = state_permit_document_source.pollutants;
+    }
+    static is(state_permit_document_source) {
+        return (StatePermitDocumentSource.is(state_permit_document_source) &&
+            StatePermitAux.is(state_permit_document_source.state_permit) &&
+            StatePermitDocument.is(state_permit_document_source.state_permit_document) &&
+            Array.isArray(state_permit_document_source.pollutants) &&
+            state_permit_document_source.pollutants.every(StatePermitDocumentSourcePollutant.is));
+    }
+}

package/dist/src/types/state_permits/StatePermitDocumentSourcePollutant.d.ts

@@ -0,0 +1,35 @@
+import { StateID } from "../State.js";
+export declare class StatePermitDocumentSourcePollutant {
+    readonly state_permit_document_source_pollutant_id: string;
+    readonly state_id: StateID;
+    readonly state_permit_id: string;
+    readonly state_permit_document_id: string;
+    readonly state_permit_document_source_id: string;
+    readonly pollutant_id: string;
+    readonly [x: string]: any;
+    constructor(state_permit_document_source_pollutant: StatePermitDocumentSourcePollutant);
+    static is(state_permit_document_source_pollutant: any): state_permit_document_source_pollutant is StatePermitDocumentSourcePollutant;
+}
+export declare class StateAirPermitDocumentSourcePollutant extends StatePermitDocumentSourcePollutant {
+    readonly TPY_text: string;
+    readonly TPY?: number;
+    readonly TPY_global_rank?: number;
+    readonly TPY_global_total?: number;
+    readonly TPY_local_rank?: number;
+    readonly TPY_local_total?: number;
+    readonly LBPH_text: string;
+    readonly LBPH?: number;
+    readonly LBPH_global_rank?: number;
+    readonly LBPH_global_total?: number;
+    readonly LBPH_local_rank?: number;
+    readonly LBPH_local_total?: number;
+    readonly [x: string]: any;
+    constructor(state_permit_document_source_pollutant: StateAirPermitDocumentSourcePollutant);
+    static is(state_permit_document_source_pollutant: any): state_permit_document_source_pollutant is StateAirPermitDocumentSourcePollutant;
+}
+export declare class StateWaterPermitDocumentSourcePollutant extends StatePermitDocumentSourcePollutant {
+    readonly freq?: string;
+    readonly [x: string]: any;
+    constructor(state_permit_document_source_pollutant: StateWaterPermitDocumentSourcePollutant);
+    static is(state_permit_document_source_pollutant: any): state_permit_document_source_pollutant is StateWaterPermitDocumentSourcePollutant;
+}

package/dist/src/types/state_permits/StatePermitDocumentSourcePollutant.js

@@ -0,0 +1,90 @@
+import { is_state_id } from "../State.js";
+export class StatePermitDocumentSourcePollutant {
+    state_permit_document_source_pollutant_id;
+    state_id;
+    state_permit_id;
+    state_permit_document_id;
+    state_permit_document_source_id;
+    pollutant_id;
+    constructor(state_permit_document_source_pollutant) {
+        if (!StatePermitDocumentSourcePollutant.is(state_permit_document_source_pollutant)) {
+            throw Error("Invalid input.");
+        }
+        this.state_permit_document_source_pollutant_id = state_permit_document_source_pollutant.state_permit_document_source_pollutant_id;
+        this.state_id = state_permit_document_source_pollutant.state_id;
+        this.state_permit_id = state_permit_document_source_pollutant.state_permit_id;
+        this.state_permit_document_id = state_permit_document_source_pollutant.state_permit_document_id;
+        this.state_permit_document_source_id = state_permit_document_source_pollutant.state_permit_document_source_id;
+        this.pollutant_id = state_permit_document_source_pollutant.pollutant_id;
+    }
+    static is(state_permit_document_source_pollutant) {
+        return (state_permit_document_source_pollutant !== undefined &&
+            typeof state_permit_document_source_pollutant.state_permit_document_source_pollutant_id === "string" &&
+            is_state_id(state_permit_document_source_pollutant.state_id) &&
+            typeof state_permit_document_source_pollutant.state_permit_id === "string" &&
+            typeof state_permit_document_source_pollutant.state_permit_document_id === "string" &&
+            typeof state_permit_document_source_pollutant.state_permit_document_source_id === "string" &&
+            typeof state_permit_document_source_pollutant.pollutant_id === "string");
+    }
+}
+export class StateAirPermitDocumentSourcePollutant extends StatePermitDocumentSourcePollutant {
+    TPY_text;
+    TPY;
+    TPY_global_rank;
+    TPY_global_total;
+    TPY_local_rank;
+    TPY_local_total;
+    LBPH_text;
+    LBPH;
+    LBPH_global_rank;
+    LBPH_global_total;
+    LBPH_local_rank;
+    LBPH_local_total;
+    constructor(state_permit_document_source_pollutant) {
+        if (!StateAirPermitDocumentSourcePollutant.is(state_permit_document_source_pollutant)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit_document_source_pollutant);
+        this.TPY_text = state_permit_document_source_pollutant.TPY_text;
+        this.TPY = state_permit_document_source_pollutant.TPY;
+        this.TPY_global_rank = state_permit_document_source_pollutant.TPY_global_rank;
+        this.TPY_global_total = state_permit_document_source_pollutant.TPY_global_total;
+        this.TPY_local_rank = state_permit_document_source_pollutant.TPY_local_rank;
+        this.TPY_local_total = state_permit_document_source_pollutant.TPY_local_total;
+        this.LBPH_text = state_permit_document_source_pollutant.LBPH_text;
+        this.LBPH = state_permit_document_source_pollutant.LBPH;
+        this.LBPH_global_rank = state_permit_document_source_pollutant.LBPH_global_rank;
+        this.LBPH_global_total = state_permit_document_source_pollutant.LBPH_global_total;
+        this.LBPH_local_rank = state_permit_document_source_pollutant.LBPH_local_rank;
+        this.LBPH_local_total = state_permit_document_source_pollutant.LBPH_local_total;
+    }
+    static is(state_permit_document_source_pollutant) {
+        return (StatePermitDocumentSourcePollutant.is(state_permit_document_source_pollutant) &&
+            typeof state_permit_document_source_pollutant.TPY_text === "string" &&
+            (state_permit_document_source_pollutant.TPY === undefined || typeof state_permit_document_source_pollutant.TPY === "number" && !isNaN(state_permit_document_source_pollutant.TPY)) &&
+            (state_permit_document_source_pollutant.TPY_global_rank === undefined || typeof state_permit_document_source_pollutant.TPY_global_rank === "number" && !isNaN(state_permit_document_source_pollutant.TPY_global_rank)) &&
+            (state_permit_document_source_pollutant.TPY_global_total === undefined || typeof state_permit_document_source_pollutant.TPY_global_total === "number" && !isNaN(state_permit_document_source_pollutant.TPY_global_total)) &&
+            (state_permit_document_source_pollutant.TPY_local_rank === undefined || typeof state_permit_document_source_pollutant.TPY_local_rank === "number" && !isNaN(state_permit_document_source_pollutant.TPY_local_rank)) &&
+            (state_permit_document_source_pollutant.TPY_local_total === undefined || typeof state_permit_document_source_pollutant.TPY_local_total === "number" && !isNaN(state_permit_document_source_pollutant.TPY_local_total)) &&
+            typeof state_permit_document_source_pollutant.LBPH_text === "string" &&
+            (state_permit_document_source_pollutant.LBPH === undefined || typeof state_permit_document_source_pollutant.LBPH === "number" && !isNaN(state_permit_document_source_pollutant.LBPH)) &&
+            (state_permit_document_source_pollutant.LBPH_global_rank === undefined || typeof state_permit_document_source_pollutant.LBPH_global_rank === "number" && !isNaN(state_permit_document_source_pollutant.LBPH_global_rank)) &&
+            (state_permit_document_source_pollutant.LBPH_global_total === undefined || typeof state_permit_document_source_pollutant.LBPH_global_total === "number" && !isNaN(state_permit_document_source_pollutant.LBPH_global_total)) &&
+            (state_permit_document_source_pollutant.LBPH_local_rank === undefined || typeof state_permit_document_source_pollutant.LBPH_local_rank === "number" && !isNaN(state_permit_document_source_pollutant.LBPH_local_rank)) &&
+            (state_permit_document_source_pollutant.LBPH_local_total === undefined || typeof state_permit_document_source_pollutant.LBPH_local_total === "number" && !isNaN(state_permit_document_source_pollutant.LBPH_local_total)));
+    }
+}
+export class StateWaterPermitDocumentSourcePollutant extends StatePermitDocumentSourcePollutant {
+    freq;
+    constructor(state_permit_document_source_pollutant) {
+        if (!StateWaterPermitDocumentSourcePollutant.is(state_permit_document_source_pollutant)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit_document_source_pollutant);
+        this.freq = state_permit_document_source_pollutant.freq;
+    }
+    static is(state_permit_document_source_pollutant) {
+        return (StatePermitDocumentSourcePollutant.is(state_permit_document_source_pollutant) &&
+            (state_permit_document_source_pollutant.freq === undefined || typeof state_permit_document_source_pollutant.freq === "string"));
+    }
+}

package/dist/src/types/state_permits/TN/TNStateFacility.d.ts

@@ -0,0 +1,7 @@
+import { StateFacility } from "../StateFacility.js";
+export declare class TNStateFacility extends StateFacility {
+    readonly state_id: "TN";
+    readonly [x: string]: any;
+    constructor(state_facility: TNStateFacility);
+    static is(state_facility: any): state_facility is TNStateFacility;
+}

package/dist/src/types/state_permits/TN/TNStateFacility.js

@@ -0,0 +1,15 @@
+import { StateFacility } from "../StateFacility.js";
+export class TNStateFacility extends StateFacility {
+    state_id;
+    constructor(state_facility) {
+        if (!TNStateFacility.is(state_facility)) {
+            throw Error("Invalid input.");
+        }
+        super(state_facility);
+        this.state_id = state_facility.state_id;
+    }
+    static is(state_facility) {
+        return (StateFacility.is(state_facility) &&
+            state_facility.state_id === "TN");
+    }
+}

package/dist/src/types/state_permits/TN/TNStatePermit.d.ts

@@ -0,0 +1,8 @@
+import { StatePermit } from "../StatePermit.js";
+export declare class TNStatePermit extends StatePermit {
+    readonly state_id: "TN";
+    readonly effective_date?: string;
+    readonly [x: string]: any;
+    constructor(state_permit: TNStatePermit);
+    static is(state_permit: any): state_permit is TNStatePermit;
+}

package/dist/src/types/state_permits/TN/TNStatePermit.js

@@ -0,0 +1,18 @@
+import { StatePermit } from "../StatePermit.js";
+export class TNStatePermit extends StatePermit {
+    state_id;
+    effective_date;
+    constructor(state_permit) {
+        if (!TNStatePermit.is(state_permit)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit);
+        this.state_id = state_permit.state_id;
+        this.effective_date = state_permit.effective_date;
+    }
+    static is(state_permit) {
+        return (StatePermit.is(state_permit) &&
+            state_permit.state_id === "TN" &&
+            (state_permit.effective_date === undefined || typeof state_permit.effective_date === "string"));
+    }
+}

package/dist/src/types/state_permits/TN/TNStatePermitDocument.d.ts

@@ -0,0 +1,8 @@
+import { StatePermitDocument } from "../StatePermitDocument.js";
+export declare class TNStatePermitDocument extends StatePermitDocument {
+    readonly state_id: "TN";
+    readonly date: string;
+    readonly [x: string]: any;
+    constructor(state_permit: TNStatePermitDocument);
+    static is(state_permit: any): state_permit is TNStatePermitDocument;
+}

package/dist/src/types/state_permits/TN/TNStatePermitDocument.js

@@ -0,0 +1,18 @@
+import { StatePermitDocument } from "../StatePermitDocument.js";
+export class TNStatePermitDocument extends StatePermitDocument {
+    state_id;
+    date;
+    constructor(state_permit) {
+        if (!TNStatePermitDocument.is(state_permit)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit);
+        this.state_id = state_permit.state_id;
+        this.date = state_permit.date;
+    }
+    static is(state_permit) {
+        return (StatePermitDocument.is(state_permit) &&
+            state_permit.state_id === "TN" &&
+            typeof state_permit.date === "string");
+    }
+}

package/dist/src/types/state_permits/WI/WIStatePermit.d.ts

@@ -0,0 +1,8 @@
+import { StatePermit } from "../StatePermit.js";
+export declare class WIStatePermit extends StatePermit {
+    readonly state_id: "WI";
+    readonly seq_id: string;
+    readonly [x: string]: any;
+    constructor(state_permit: WIStatePermit);
+    static is(state_permit: any): state_permit is WIStatePermit;
+}

package/dist/src/types/state_permits/WI/WIStatePermit.js

@@ -0,0 +1,18 @@
+import { StatePermit } from "../StatePermit.js";
+export class WIStatePermit extends StatePermit {
+    state_id;
+    seq_id;
+    constructor(state_permit) {
+        if (!WIStatePermit.is(state_permit)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit);
+        this.state_id = state_permit.state_id;
+        this.seq_id = state_permit.seq_id;
+    }
+    static is(state_permit) {
+        return (StatePermit.is(state_permit) &&
+            state_permit.state_id === "WI" &&
+            typeof state_permit.seq_id === "string");
+    }
+}

package/dist/src/types/state_permits/WI/WIStatePermitDocument.d.ts

@@ -0,0 +1,7 @@
+import { StatePermitDocument } from "../StatePermitDocument.js";
+export declare class WIStatePermitDocument extends StatePermitDocument {
+    readonly state_id: "WI";
+    readonly [x: string]: any;
+    constructor(state_permit: WIStatePermitDocument);
+    static is(state_permit: any): state_permit is WIStatePermitDocument;
+}

package/dist/src/types/state_permits/WI/WIStatePermitDocument.js

@@ -0,0 +1,15 @@
+import { StatePermitDocument } from "../StatePermitDocument.js";
+export class WIStatePermitDocument extends StatePermitDocument {
+    state_id;
+    constructor(state_permit) {
+        if (!WIStatePermitDocument.is(state_permit)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit);
+        this.state_id = state_permit.state_id;
+    }
+    static is(state_permit) {
+        return (StatePermitDocument.is(state_permit) &&
+            state_permit.state_id === "WI");
+    }
+}

package/dist/src/types/twitter/TwitterTweet.d.ts

@@ -0,0 +1,21 @@
+export declare class TwitterTweet {
+    readonly twitter_tweet_id: string;
+    readonly twitter_user_id: string;
+    readonly publish_time: string;
+    readonly supreme_twitter_tweet_id: string;
+    readonly draft_twitter_tweet_ids: string[];
+    readonly community_id?: string;
+    readonly is_sensitive: boolean;
+    readonly is_sponsored: boolean;
+    readonly lang_id: string;
+    readonly references_json: string;
+    readonly geo_json?: string;
+    readonly text: string;
+    readonly content_json?: string;
+    readonly media_json?: string;
+    readonly attachments_json?: string;
+    readonly entities_json?: string;
+    readonly reply_settings_type_id: string;
+    constructor(twitter_tweet: TwitterTweet);
+    static is(twitter_tweet: any): twitter_tweet is TwitterTweet;
+}

package/dist/src/types/twitter/TwitterTweet.js

@@ -0,0 +1,61 @@
+export class TwitterTweet {
+    twitter_tweet_id;
+    twitter_user_id;
+    publish_time;
+    supreme_twitter_tweet_id;
+    draft_twitter_tweet_ids;
+    community_id;
+    is_sensitive;
+    is_sponsored;
+    lang_id;
+    references_json;
+    geo_json;
+    text;
+    content_json;
+    media_json;
+    attachments_json;
+    entities_json;
+    reply_settings_type_id;
+    constructor(twitter_tweet) {
+        if (!TwitterTweet.is(twitter_tweet)) {
+            throw Error("Invalid input.");
+        }
+        this.twitter_tweet_id = twitter_tweet.twitter_tweet_id;
+        this.twitter_user_id = twitter_tweet.twitter_user_id;
+        this.publish_time = twitter_tweet.publish_time;
+        this.supreme_twitter_tweet_id = twitter_tweet.supreme_twitter_tweet_id;
+        this.draft_twitter_tweet_ids = twitter_tweet.draft_twitter_tweet_ids;
+        this.community_id = twitter_tweet.community_id;
+        this.is_sensitive = twitter_tweet.is_sensitive;
+        this.is_sponsored = twitter_tweet.is_sponsored;
+        this.lang_id = twitter_tweet.lang_id;
+        this.references_json = twitter_tweet.references_json;
+        this.geo_json = twitter_tweet.geo_json;
+        this.text = twitter_tweet.text;
+        this.content_json = twitter_tweet.content_json;
+        this.media_json = twitter_tweet.media_json;
+        this.attachments_json = twitter_tweet.attachments_json;
+        this.entities_json = twitter_tweet.entities_json;
+        this.reply_settings_type_id = twitter_tweet.reply_settings_type_id;
+    }
+    static is(twitter_tweet) {
+        return (twitter_tweet !== undefined &&
+            typeof twitter_tweet.twitter_tweet_id === "string" &&
+            typeof twitter_tweet.twitter_user_id === "string" &&
+            typeof twitter_tweet.publish_time === "string" &&
+            typeof twitter_tweet.supreme_twitter_tweet_id === "string" &&
+            Array.isArray(twitter_tweet.draft_twitter_tweet_ids) && twitter_tweet.draft_twitter_tweet_ids.every((draft_twitter_tweet_id) => typeof draft_twitter_tweet_id === "string") &&
+            (twitter_tweet.community_id === undefined || typeof twitter_tweet.community_id === "string") &&
+            typeof twitter_tweet.is_sensitive === "boolean" &&
+            typeof twitter_tweet.is_sponsored === "boolean" &&
+            typeof twitter_tweet.lang_id === "string" &&
+            typeof twitter_tweet.references_json === "string" &&
+            (twitter_tweet.geo_json === undefined || typeof twitter_tweet.geo_json === "string") &&
+            typeof twitter_tweet.text === "string" &&
+            (twitter_tweet.content_json === undefined || typeof twitter_tweet.content_json === "string") &&
+            (twitter_tweet.media_json === undefined || typeof twitter_tweet.media_json === "string") &&
+            (twitter_tweet.attachments_json === undefined || typeof twitter_tweet.attachments_json === "string") &&
+            (twitter_tweet.entities_json === undefined || typeof twitter_tweet.entities_json === "string") &&
+            typeof twitter_tweet.reply_settings_type_id === "string");
+    }
+}

package/dist/src/types/twitter/TwitterUser.d.ts

@@ -0,0 +1,17 @@
+export declare class TwitterUser {
+    readonly twitter_user_id: string;
+    readonly username: string;
+    readonly name: string;
+    readonly url: string;
+    readonly description: string;
+    readonly location: string;
+    readonly create_time: string;
+    readonly affiliated_twitter_user_id?: string;
+    readonly is_protected: boolean;
+    readonly is_parody: boolean;
+    readonly subscription_type_id: string;
+    readonly verification_type_id: string;
+    readonly entities?: string;
+    constructor(twitter_user: TwitterUser);
+    static is(twitter_user: any): twitter_user is TwitterUser;
+}