triangle-types 1.0.0

package/dist/src/types/federal_rules/FederalRuleTitle.d.ts

@@ -0,0 +1,8 @@
+export declare class FederalRuleTitle {
+    readonly federal_rule_title_id: number;
+    readonly name: string;
+    readonly is_reserved: boolean;
+    readonly s3_id?: string;
+    constructor(federal_rule_title: FederalRuleTitle);
+    static is(federal_rule_title: any): federal_rule_title is FederalRuleTitle;
+}

package/dist/src/types/federal_rules/FederalRuleTitle.js

@@ -0,0 +1,22 @@
+export class FederalRuleTitle {
+    federal_rule_title_id;
+    name;
+    is_reserved;
+    s3_id;
+    constructor(federal_rule_title) {
+        if (!FederalRuleTitle.is(federal_rule_title)) {
+            throw Error("Invalid input.");
+        }
+        this.federal_rule_title_id = federal_rule_title.federal_rule_title_id;
+        this.name = federal_rule_title.name;
+        this.is_reserved = federal_rule_title.is_reserved;
+        this.s3_id = federal_rule_title.s3_id;
+    }
+    static is(federal_rule_title) {
+        return (federal_rule_title !== undefined &&
+            typeof federal_rule_title.federal_rule_title_id === "number" &&
+            typeof federal_rule_title.name === "string" &&
+            typeof federal_rule_title.is_reserved === "boolean" &&
+            (federal_rule_title.s3_id === undefined || typeof federal_rule_title.s3_id === "string"));
+    }
+}

package/dist/src/types/press/PressArticle.d.ts

@@ -0,0 +1,12 @@
+export declare class PressArticle {
+    readonly press_article_id: string;
+    readonly publish_date: string;
+    readonly title: string;
+    readonly publisher?: string;
+    readonly domain: string;
+    readonly url: string;
+    readonly relevance?: string;
+    readonly s3_id?: string;
+    constructor(press_article: PressArticle);
+    static is(press_article: any): press_article is PressArticle;
+}

package/dist/src/types/press/PressArticle.js

@@ -0,0 +1,34 @@
+export class PressArticle {
+    press_article_id;
+    publish_date;
+    title;
+    publisher;
+    domain;
+    url;
+    relevance;
+    s3_id;
+    constructor(press_article) {
+        if (!PressArticle.is(press_article)) {
+            throw Error("Invalid input.");
+        }
+        this.press_article_id = press_article.press_article_id;
+        this.publish_date = press_article.publish_date;
+        this.title = press_article.title;
+        this.publisher = press_article.publisher;
+        this.domain = press_article.domain;
+        this.url = press_article.url;
+        this.relevance = press_article.relevance;
+        this.s3_id = press_article.s3_id;
+    }
+    static is(press_article) {
+        return (press_article !== undefined &&
+            typeof press_article.press_article_id === "string" &&
+            typeof press_article.publish_date === "string" &&
+            typeof press_article.title === "string" &&
+            (press_article.publisher === undefined || typeof press_article.publisher === "string") &&
+            typeof press_article.domain === "string" &&
+            typeof press_article.url === "string" &&
+            (press_article.relevance === undefined || typeof press_article.relevance === "string") &&
+            (press_article.s3_id === undefined || typeof press_article.s3_id === "string"));
+    }
+}

package/dist/src/types/press/PressArticleTag.d.ts

@@ -0,0 +1,16 @@
+import { PressArticle } from "./PressArticle.js";
+export declare class PressArticleTag {
+    readonly press_article_id: string;
+    readonly tag_id: string;
+    readonly publish_date: string;
+    readonly relevance?: string;
+    readonly sentiment?: string;
+    readonly [x: string]: any;
+    constructor(press_article_tag: PressArticleTag);
+    static is(press_article_tag: any): press_article_tag is PressArticleTag;
+}
+export declare class PressArticleTagAux extends PressArticleTag {
+    readonly press_article: PressArticle;
+    constructor(press_article_tag: any);
+    static is(press_article_tag: any): press_article_tag is PressArticleTagAux;
+}

package/dist/src/types/press/PressArticleTag.js

@@ -0,0 +1,40 @@
+import { PressArticle } from "./PressArticle.js";
+export class PressArticleTag {
+    press_article_id;
+    tag_id;
+    publish_date;
+    relevance;
+    sentiment;
+    constructor(press_article_tag) {
+        if (!PressArticleTag.is(press_article_tag)) {
+            throw Error("Invalid input.");
+        }
+        this.press_article_id = press_article_tag.press_article_id;
+        this.tag_id = press_article_tag.tag_id;
+        this.publish_date = press_article_tag.publish_date;
+        this.relevance = press_article_tag.relevance;
+        this.sentiment = press_article_tag.sentiment;
+    }
+    static is(press_article_tag) {
+        return (press_article_tag !== undefined &&
+            typeof press_article_tag.press_article_id === "string" &&
+            typeof press_article_tag.tag_id === "string" &&
+            typeof press_article_tag.publish_date === "string" &&
+            (press_article_tag.relevance === undefined || typeof press_article_tag.relevance === "string") &&
+            (press_article_tag.sentiment === undefined || typeof press_article_tag.sentiment === "string"));
+    }
+}
+export class PressArticleTagAux extends PressArticleTag {
+    press_article;
+    constructor(press_article_tag) {
+        if (!PressArticleTagAux.is(press_article_tag)) {
+            throw Error("Invalid input.");
+        }
+        super(press_article_tag);
+        this.press_article = press_article_tag.press_article;
+    }
+    static is(press_article_tag) {
+        return (PressArticleTag.is(press_article_tag) &&
+            PressArticle.is(press_article_tag.press_article));
+    }
+}

package/dist/src/types/state_permits/AR/ARStateFacility.d.ts

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

package/dist/src/types/state_permits/AR/ARStateFacility.js

@@ -0,0 +1,15 @@
+import { StateFacility } from "../StateFacility.js";
+export class ARStateFacility extends StateFacility {
+    state_id;
+    constructor(state_facility) {
+        if (!ARStateFacility.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 === "AR");
+    }
+}

package/dist/src/types/state_permits/AR/ARStatePermit.d.ts

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

package/dist/src/types/state_permits/AR/ARStatePermit.js

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

package/dist/src/types/state_permits/AR/ARStatePermitDocument.d.ts

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

package/dist/src/types/state_permits/AR/ARStatePermitDocument.js

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

package/dist/src/types/state_permits/KY/KYStateFacility.d.ts

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

package/dist/src/types/state_permits/KY/KYStateFacility.js

@@ -0,0 +1,15 @@
+import { StateFacility } from "../StateFacility.js";
+export class KYStateFacility extends StateFacility {
+    state_id;
+    constructor(state_facility) {
+        if (!KYStateFacility.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 === "KY");
+    }
+}

package/dist/src/types/state_permits/KY/KYStatePermit.d.ts

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

package/dist/src/types/state_permits/KY/KYStatePermit.js

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

package/dist/src/types/state_permits/KY/KYStatePermitDocument.d.ts

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

package/dist/src/types/state_permits/KY/KYStatePermitDocument.js

@@ -0,0 +1,18 @@
+import { StatePermitDocument } from "../StatePermitDocument.js";
+export class KYStatePermitDocument extends StatePermitDocument {
+    state_id;
+    date;
+    constructor(state_permit) {
+        if (!KYStatePermitDocument.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 === "KY" &&
+            (state_permit.date === undefined || typeof state_permit.date === "string"));
+    }
+}

package/dist/src/types/state_permits/NC/NCStateFacility.d.ts

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

package/dist/src/types/state_permits/NC/NCStateFacility.js

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

package/dist/src/types/state_permits/NC/NCStatePermit.d.ts

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

package/dist/src/types/state_permits/NC/NCStatePermit.js

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

package/dist/src/types/state_permits/NC/NCStatePermitDocument.d.ts

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

package/dist/src/types/state_permits/NC/NCStatePermitDocument.js

@@ -0,0 +1,18 @@
+import { StatePermitDocument } from "../StatePermitDocument.js";
+export class NCStatePermitDocument extends StatePermitDocument {
+    state_id;
+    date;
+    constructor(state_permit) {
+        if (!NCStatePermitDocument.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 === "NC" &&
+            (state_permit.date === undefined || typeof state_permit.date === "string"));
+    }
+}

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

@@ -0,0 +1,20 @@
+import { StateID } from "../State.js";
+import { StatePermitAux } from "./StatePermit.js";
+export declare class StateFacility {
+    readonly state_facility_id: string;
+    readonly state_id: StateID;
+    readonly facility_id: string;
+    readonly name: string;
+    readonly is_active?: boolean;
+    readonly facility_type_id?: string;
+    readonly site_address_city?: string;
+    readonly site_address_county?: string;
+    readonly [x: string]: any;
+    constructor(state_facility: StateFacility);
+    static is(state_facility: any): state_facility is StateFacility;
+}
+export declare class StateFacilityAux extends StateFacility {
+    readonly state_permits: StatePermitAux[];
+    constructor(state_facility: StateFacilityAux);
+    static is(state_facility: any): state_facility is StateFacilityAux;
+}

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

@@ -0,0 +1,49 @@
+import { is_state_id } from "../State.js";
+import { StatePermitAux } from "./StatePermit.js";
+export class StateFacility {
+    state_facility_id;
+    state_id;
+    facility_id;
+    name;
+    is_active;
+    facility_type_id;
+    site_address_city;
+    site_address_county;
+    constructor(state_facility) {
+        if (!StateFacility.is(state_facility)) {
+            throw Error("Invalid input.");
+        }
+        this.state_facility_id = state_facility.state_facility_id;
+        this.state_id = state_facility.state_id;
+        this.facility_id = state_facility.facility_id;
+        this.name = state_facility.name;
+        this.is_active = state_facility.is_active;
+        this.facility_type_id = state_facility.facility_type_id;
+        this.site_address_city = state_facility.site_address_city;
+    }
+    static is(state_facility) {
+        return (state_facility !== undefined &&
+            is_state_id(state_facility.state_id) &&
+            typeof state_facility.state_facility_id === "string" &&
+            typeof state_facility.facility_id === "string" &&
+            typeof state_facility.name === "string" &&
+            (state_facility.is_active === undefined || typeof state_facility.is_active === "boolean") &&
+            (state_facility.facility_type_id === undefined || typeof state_facility.facility_type_id === "string") &&
+            (state_facility.site_address_city === undefined || typeof state_facility.site_address_city === "string"));
+    }
+}
+export class StateFacilityAux extends StateFacility {
+    state_permits;
+    constructor(state_facility) {
+        if (!StateFacilityAux.is(state_facility)) {
+            throw Error("Invalid input.");
+        }
+        super(state_facility);
+        this.state_permits = state_facility.state_permits;
+    }
+    static is(state_facility) {
+        return (StateFacility.is(state_facility) &&
+            Array.isArray(state_facility.state_permits) &&
+            state_facility.state_permits.every(StatePermitAux.is));
+    }
+}

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

@@ -0,0 +1,27 @@
+import { StateID } from "../State.js";
+import { StateFacility } from "./StateFacility.js";
+export declare class StatePermit {
+    readonly state_permit_id: string;
+    readonly state_id: StateID;
+    readonly permit_id: string;
+    readonly state_facility_id: string;
+    readonly issue_date?: string;
+    readonly expiration_date?: string;
+    readonly status?: string;
+    readonly permit_type_id?: string;
+    readonly permit_subtype_id?: string;
+    readonly [x: string]: any;
+    constructor(state_permit: StatePermit);
+    static is(state_permit: any): state_permit is StatePermit;
+}
+export declare class StateWaterPermit extends StatePermit {
+    readonly permit_type_id: "WATER-NPDES";
+    readonly max_document_id?: string;
+    constructor(state_permit: StateWaterPermit);
+    static is(state_permit: any): state_permit is StateWaterPermit;
+}
+export declare class StatePermitAux extends StatePermit {
+    readonly state_facility: StateFacility;
+    constructor(state_permit: StatePermitAux);
+    static is(state_permit: any): state_permit is StatePermitAux;
+}

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

@@ -0,0 +1,69 @@
+import { is_state_id } from "../State.js";
+import { StateFacility } from "./StateFacility.js";
+export class StatePermit {
+    state_permit_id;
+    state_id;
+    permit_id;
+    state_facility_id;
+    issue_date;
+    expiration_date;
+    status;
+    permit_type_id;
+    permit_subtype_id;
+    constructor(state_permit) {
+        if (!StatePermit.is(state_permit)) {
+            throw Error("Invalid input.");
+        }
+        this.state_permit_id = state_permit.state_permit_id;
+        this.state_id = state_permit.state_id;
+        this.permit_id = state_permit.permit_id;
+        this.state_facility_id = state_permit.state_facility_id;
+        this.issue_date = state_permit.issue_date;
+        this.expiration_date = state_permit.expiration_date;
+        this.status = state_permit.status;
+        this.permit_type_id = state_permit.permit_type_id;
+    }
+    static is(state_permit) {
+        return (state_permit !== undefined &&
+            typeof state_permit.state_permit_id === "string" &&
+            is_state_id(state_permit.state_id) &&
+            typeof state_permit.permit_id === "string" &&
+            typeof state_permit.state_facility_id === "string" &&
+            (state_permit.issue_date === undefined || typeof state_permit.issue_date === "string") &&
+            (state_permit.expiration_date === undefined || typeof state_permit.expiration_date === "string") &&
+            (state_permit.status === undefined || typeof state_permit.status === "string") &&
+            (state_permit.permit_type_id === undefined || typeof state_permit.permit_type_id === "string") &&
+            (state_permit.permit_subtype_id === undefined || typeof state_permit.permit_subtype_id === "string"));
+    }
+}
+export class StateWaterPermit extends StatePermit {
+    permit_type_id;
+    max_document_id;
+    constructor(state_permit) {
+        if (!StateWaterPermit.is(state_permit)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit);
+        this.permit_type_id = state_permit.permit_type_id;
+        this.max_document_id = state_permit.max_document_id;
+    }
+    static is(state_permit) {
+        return (StatePermit.is(state_permit) &&
+            state_permit.permit_type_id === "WATER-NPDES" &&
+            (state_permit.max_document_id === undefined || typeof state_permit.max_document_id === "string"));
+    }
+}
+export class StatePermitAux extends StatePermit {
+    state_facility;
+    constructor(state_permit) {
+        if (!StatePermitAux.is(state_permit)) {
+            throw Error("Invalid input.");
+        }
+        super(state_permit);
+        this.state_facility = state_permit.state_facility;
+    }
+    static is(state_permit) {
+        return (StatePermit.is(state_permit) &&
+            StateFacility.is(state_permit.state_facility));
+    }
+}

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

@@ -0,0 +1,37 @@
+import { StateID } from "../State.js";
+import { StatePermitDocumentSourceAux } from "./StatePermitDocumentSource.js";
+export declare class StatePermitComment {
+    readonly comment_text: string;
+    readonly response_text: string;
+    constructor(state_permit_comment: StatePermitComment);
+    static is(state_permit_comment: any): state_permit_comment is StatePermitComment;
+}
+export declare class StatePermitDocument {
+    readonly state_permit_document_id: string;
+    readonly state_id: StateID;
+    readonly state_permit_id: string;
+    readonly document_id: string;
+    readonly permit_type_id: string;
+    readonly document_type: string;
+    readonly document_type_id?: string;
+    readonly name: string;
+    readonly s3_id?: string;
+    readonly s3_id_txt?: string;
+    readonly source_ids?: string[];
+    readonly comments?: StatePermitComment[];
+    readonly [x: string]: any;
+    constructor(state_permit_document: StatePermitDocument);
+    static is(state_permit_document: any): state_permit_document is StatePermitDocument;
+}
+export declare class StateWaterPermitDocument extends StatePermitDocument {
+    readonly permit_type_id: "WATER-NPDES";
+    readonly freq_fish_tissue?: string;
+    readonly [x: string]: any;
+    constructor(state_permit_document: StateWaterPermitDocument);
+    static is(state_permit_document: any): state_permit_document is StateWaterPermitDocument;
+}
+export declare class StatePermitDocumentAux extends StatePermitDocument {
+    readonly sources: StatePermitDocumentSourceAux[];
+    constructor(state_permit_document: StatePermitDocumentAux);
+    static is(state_permit_document: any): state_permit_document is StatePermitDocumentAux;
+}