triangle-types 1.0.0

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

@@ -0,0 +1,21 @@
+import { StateFacility } from "../StateFacility"
+
+export class ARStateFacility extends StateFacility {
+    readonly state_id : "AR"
+    readonly [x : string] : any
+
+    constructor(state_facility : ARStateFacility) {
+        if (!ARStateFacility.is(state_facility)) {
+            throw Error("Invalid input.")
+        }
+        super(state_facility)
+        this.state_id = state_facility.state_id
+    }
+
+    static is(state_facility : any) : state_facility is ARStateFacility {
+        return (
+            StateFacility.is(state_facility) &&
+            state_facility.state_id === "AR"
+        )
+    }
+}

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

@@ -0,0 +1,24 @@
+import { StatePermit } from "../StatePermit"
+
+export class ARStatePermit extends StatePermit {
+    readonly state_id : "AR"
+    readonly void_date? : string
+    readonly [x : string] : any
+
+    constructor(state_permit : ARStatePermit) {
+        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 : any) : state_permit is ARStatePermit {
+        return (
+            StatePermit.is(state_permit) &&
+            state_permit.state_id === "AR" &&
+            (state_permit.void_date === undefined || typeof state_permit.void_date === "string")
+        )
+    }
+}

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

@@ -0,0 +1,27 @@
+import { StatePermitDocument } from "../StatePermitDocument"
+
+export class ARStatePermitDocument extends StatePermitDocument {
+    readonly state_id : "AR"
+    readonly date : string
+    readonly url : string
+    readonly [x : string] : any
+
+    constructor(state_permit : ARStatePermitDocument) {
+        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 : any) : state_permit is ARStatePermitDocument {
+        return (
+            StatePermitDocument.is(state_permit) &&
+            state_permit.state_id === "AR" &&
+            typeof state_permit.date === "string" &&
+            typeof state_permit.url === "string"
+        )
+    }
+}

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

@@ -0,0 +1,22 @@
+import { is_state_id, StateID } from "../../State"
+import { StateFacility } from "../StateFacility"
+
+export class KYStateFacility extends StateFacility {
+    readonly state_id : "KY"
+    readonly [x : string] : any
+
+    constructor(state_facility : KYStateFacility) {
+        if (!KYStateFacility.is(state_facility)) {
+            throw Error("Invalid input.")
+        }
+        super(state_facility)
+        this.state_id = state_facility.state_id
+    }
+
+    static is(state_facility : any) : state_facility is KYStateFacility {
+        return (
+            StateFacility.is(state_facility) &&
+            state_facility.state_id === "KY"
+        )
+    }
+}

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

@@ -0,0 +1,21 @@
+import { StatePermit } from "../StatePermit"
+
+export class KYStatePermit extends StatePermit {
+    readonly state_id : "KY"
+    readonly [x : string] : any
+
+    constructor(state_permit : KYStatePermit) {
+        if (!KYStatePermit.is(state_permit)) {
+            throw Error("Invalid input.")
+        }
+        super(state_permit)
+        this.state_id = state_permit.state_id
+    }
+
+    static is(state_permit : any) : state_permit is KYStatePermit {
+        return (
+            StatePermit.is(state_permit) &&
+            state_permit.state_id === "KY"
+        )
+    }
+}

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

@@ -0,0 +1,24 @@
+import { StatePermitDocument } from "../StatePermitDocument"
+
+export class KYStatePermitDocument extends StatePermitDocument {
+    readonly state_id : "KY"
+    readonly date? : string
+    readonly [x : string] : any
+
+    constructor(state_permit : KYStatePermitDocument) {
+        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 : any) : state_permit is KYStatePermitDocument {
+        return (
+            StatePermitDocument.is(state_permit) &&
+            state_permit.state_id === "KY" &&
+            (state_permit.date === undefined || typeof state_permit.date === "string")
+        )
+    }
+}

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

@@ -0,0 +1,24 @@
+import { StateFacility } from "../StateFacility"
+
+export class NCStateFacility extends StateFacility {
+    readonly state_id : "NC"
+    readonly owner : string
+    readonly [x : string] : any
+
+    constructor(state_facility : NCStateFacility) {
+        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 : any) : state_facility is NCStateFacility {
+        return (
+            StateFacility.is(state_facility) &&
+            state_facility.state_id === "NC" &&
+            typeof state_facility.owner === "string"
+        )
+    }
+}

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

@@ -0,0 +1,22 @@
+import { StatePermit } from "../StatePermit"
+
+
+export class NCStatePermit extends StatePermit {
+    readonly state_id : "NC"
+    readonly [x : string] : any
+
+    constructor(state_permit : NCStatePermit) {
+        if (!NCStatePermit.is(state_permit)) {
+            throw Error("Invalid input.")
+        }
+        super(state_permit)
+        this.state_id = state_permit.state_id
+    }
+
+    static is(state_permit : any) : state_permit is NCStatePermit {
+        return (
+            StatePermit.is(state_permit) &&
+            state_permit.state_id === "NC"
+        )
+    }
+}

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

@@ -0,0 +1,24 @@
+import { StatePermitDocument } from "../StatePermitDocument"
+
+export class NCStatePermitDocument extends StatePermitDocument {
+    readonly state_id : "NC"
+    readonly date? : string
+    readonly [x : string] : any
+
+    constructor(state_permit : NCStatePermitDocument) {
+        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 : any) : state_permit is NCStatePermitDocument {
+        return (
+            StatePermitDocument.is(state_permit) &&
+            state_permit.state_id === "NC" &&
+            (state_permit.date === undefined || typeof state_permit.date === "string")
+        )
+    }
+}

package/src/types/state_permits/StateFacility.ts

@@ -0,0 +1,60 @@
+import { is_state_id, StateID } from "../State"
+import { StatePermitAux } from "./StatePermit"
+
+export 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) {
+        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 : any) : state_facility is StateFacility {
+        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 {
+    readonly state_permits : StatePermitAux[]
+
+    constructor(state_facility : StateFacilityAux) {
+        if (!StateFacilityAux.is(state_facility)) {
+            throw Error("Invalid input.")
+        }
+        super(state_facility)
+        this.state_permits = state_facility.state_permits
+    }
+
+    static is(state_facility : any) : state_facility is StateFacilityAux {
+        return (
+            StateFacility.is(state_facility) &&
+            Array.isArray(state_facility.state_permits) &&
+            state_facility.state_permits.every(StatePermitAux.is)
+        )
+    }
+}

package/src/types/state_permits/StatePermit.ts

@@ -0,0 +1,85 @@
+import { is_state_id, StateID } from "../State"
+import { StateFacility } from "./StateFacility"
+
+export 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) {
+        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 : any) : state_permit is StatePermit {
+        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 {
+    readonly permit_type_id : "WATER-NPDES"
+    readonly max_document_id? : string
+
+    constructor(state_permit : StateWaterPermit) {
+        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 : any) : state_permit is StateWaterPermit {
+        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 {
+    readonly state_facility : StateFacility
+
+    constructor(state_permit : StatePermitAux) {
+        if (!StatePermitAux.is(state_permit)) {
+            throw Error("Invalid input.")
+        }
+        super(state_permit)
+        this.state_facility = state_permit.state_facility
+    }
+
+    static is(state_permit : any) : state_permit is StatePermitAux {
+        return (
+            StatePermit.is(state_permit) &&
+            StateFacility.is(state_permit.state_facility)
+        )
+    }
+}

package/src/types/state_permits/StatePermitDocument.ts

@@ -0,0 +1,118 @@
+import { is_state_id, StateID } from "../State"
+import { StatePermitDocumentSourceAux } from "./StatePermitDocumentSource"
+
+export class StatePermitComment {
+    readonly comment_text : string
+    readonly response_text : string
+
+
+    constructor(state_permit_comment : StatePermitComment) {
+        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 : any) : state_permit_comment is StatePermitComment {
+        return (
+            state_permit_comment !== undefined &&
+            typeof state_permit_comment.comment_text === "string" &&
+            typeof state_permit_comment.response_text === "string"
+        )
+    }
+}
+
+export 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) {
+        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 : any) : state_permit_document is StatePermitDocument {
+        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 : any) => 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 {
+    readonly permit_type_id : "WATER-NPDES"
+    readonly freq_fish_tissue? : string
+    readonly [x : string] : any
+
+    constructor(state_permit_document : StateWaterPermitDocument) {
+        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 : any) : state_permit_document is StateWaterPermitDocument {
+        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 {
+    readonly sources : StatePermitDocumentSourceAux[]
+
+    constructor(state_permit_document : StatePermitDocumentAux) {
+        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 : any) : state_permit_document is StatePermitDocumentAux {
+        return (
+            StatePermitDocument.is(state_permit_document) &&
+            Array.isArray(state_permit_document.sources) && state_permit_document.sources.every(StatePermitDocumentSourceAux.is)
+        )
+    }
+}

package/src/types/state_permits/StatePermitDocumentSource.ts

@@ -0,0 +1,146 @@
+import { is_state_id, StateID } from "../State"
+import { StatePermitAux } from "./StatePermit"
+import { StatePermitDocument } from "./StatePermitDocument"
+import { StatePermitDocumentSourcePollutant } from "./StatePermitDocumentSourcePollutant"
+
+export 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) {
+        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 : any) : state_permit_document_source is StatePermitDocumentSource {
+        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 : any) => typeof pollutant_id === "string"))
+        )
+    }
+}
+
+export 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) {
+        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 : any) : state_permit_document_source is StateWaterPermitDocumentSource {
+        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 {
+    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) {
+        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 : any) : state_permit_document_source is StateAirPermitDocumentSource {
+        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 : any) => 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 : any) => typeof local_state_permit_document_source_id === "string"))
+        )
+    }
+}
+
+export class StatePermitDocumentSourceAux extends StatePermitDocumentSource {
+    readonly state_permit : StatePermitAux
+    readonly state_permit_document : StatePermitDocument
+    readonly pollutants : StatePermitDocumentSourcePollutant[]
+
+    constructor(state_permit_document_source : StatePermitDocumentSourceAux) {
+        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 : any) : state_permit_document_source is StatePermitDocumentSourceAux {
+        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)
+        )
+    }
+}