airbyte-faros-destination 0.1.55 → 0.1.58

package/README.md

@@ -157,5 +157,10 @@ Example `catalog.json`
 }
 ```
 
+**Tip**: you can even pipe data directly from your custom source into your custom destination without Airbyte server while prefixing your streams (as expected by Faros Destination):
+```shell
+<my-source-command> | jq -c -R 'fromjson? | select(.type == "RECORD") | .record.stream = "mydatasource__CustomSource__\(.record.stream)"' | <my-destination-command>
+```
+
 ### Additional Commands
 Run `./bin/main --help` for detailed information on available commands.

package/lib/community/hasura-client.d.ts

@@ -8,7 +8,7 @@ export declare class HasuraClient {
     private readonly references;
     private readonly backReferences;
     private sortedModelDependencies;
-    constructor(url: string);
+    constructor(url: string, adminSecret?: string);
     healthCheck(): Promise<void>;
     private fetchDbSource;
     loadSchema(): Promise<void>;

package/lib/community/hasura-client.js

@@ -16,7 +16,7 @@ const traverse_1 = __importDefault(require("traverse"));
 const verror_1 = require("verror");
 const types_1 = require("./types");
 class HasuraClient {
-    constructor(url) {
+    constructor(url, adminSecret) {
         this.logger = new faros_airbyte_cdk_1.AirbyteLogger();
         this.primaryKeys = {};
         this.scalars = {};
@@ -24,7 +24,10 @@ class HasuraClient {
         this.backReferences = {};
         this.api = axios_1.default.create({
             baseURL: url,
-            headers: { 'X-Hasura-Role': 'admin' },
+            headers: {
+                'X-Hasura-Role': 'admin',
+                ...(adminSecret && { 'X-Hasura-Admin-Secret': adminSecret }),
+            },
         });
     }
     async healthCheck() {

package/lib/converters/converter.d.ts

@@ -1,4 +1,4 @@
-import { AirbyteConfig, AirbyteRecord } from 'faros-airbyte-cdk';
+import { AirbyteConfig, AirbyteLogger, AirbyteRecord } from 'faros-airbyte-cdk';
 import { FarosClient } from 'faros-feeds-sdk';
 import { Dictionary } from 'ts-essentials';
 /** Airbyte -> Faros record converter */
@@ -19,9 +19,10 @@ export declare abstract class Converter {
 export declare function parseObjectConfig<T>(obj: any, name: string): T | undefined;
 /** Stream context to store records by stream and other helpers */
 export declare class StreamContext {
+    readonly logger: AirbyteLogger;
     readonly config: AirbyteConfig;
     readonly farosClient?: FarosClient;
-    constructor(config: AirbyteConfig, farosClient?: FarosClient);
+    constructor(logger: AirbyteLogger, config: AirbyteConfig, farosClient?: FarosClient);
     private readonly recordsByStreamName;
     getAll(streamName: string): Dictionary<AirbyteRecord>;
     get(streamName: string, id: string): AirbyteRecord | undefined;

package/lib/converters/converter.js

@@ -44,7 +44,8 @@ function parseObjectConfig(obj, name) {
 exports.parseObjectConfig = parseObjectConfig;
 /** Stream context to store records by stream and other helpers */
 class StreamContext {
-    constructor(config, farosClient) {
+    constructor(logger, config, farosClient) {
+        this.logger = logger;
         this.config = config;
         this.farosClient = farosClient;
         this.recordsByStreamName = {};

package/lib/converters/firehydrant/common.d.ts

@@ -0,0 +1,20 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { Converter, StreamContext } from '../converter';
+declare type ApplicationMapping = Record<string, {
+    name: string;
+    platform?: string;
+}>;
+interface FirehHydrantConfig {
+    application_mapping?: ApplicationMapping;
+    max_description_length?: number;
+}
+/** Firehydrant converter base */
+export declare abstract class FireHydrantConverter extends Converter {
+    source: string;
+    /** Almost every Firehydrant record have id property */
+    id(record: AirbyteRecord): any;
+    protected firehydrantConfig(ctx: StreamContext): FirehHydrantConfig;
+    protected maxDescriptionLength(ctx: StreamContext): number;
+    protected applicationMapping(ctx: StreamContext): ApplicationMapping;
+}
+export {};

package/lib/converters/firehydrant/common.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FireHydrantConverter = void 0;
+const converter_1 = require("../converter");
+const MAX_DESCRIPTION_LENGTH = 1000;
+/** Firehydrant converter base */
+class FireHydrantConverter extends converter_1.Converter {
+    constructor() {
+        super(...arguments);
+        this.source = 'FireHydrant';
+    }
+    /** Almost every Firehydrant record have id property */
+    id(record) {
+        var _a, _b;
+        return (_b = (_a = record === null || record === void 0 ? void 0 : record.record) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.id;
+    }
+    firehydrantConfig(ctx) {
+        var _a, _b;
+        return (_b = (_a = ctx.config.source_specific_configs) === null || _a === void 0 ? void 0 : _a.firehydrant) !== null && _b !== void 0 ? _b : {};
+    }
+    maxDescriptionLength(ctx) {
+        var _a;
+        return ((_a = this.firehydrantConfig(ctx).max_description_length) !== null && _a !== void 0 ? _a : MAX_DESCRIPTION_LENGTH);
+    }
+    applicationMapping(ctx) {
+        var _a, _b;
+        return ((_b = (0, converter_1.parseObjectConfig)((_a = this.firehydrantConfig(ctx)) === null || _a === void 0 ? void 0 : _a.application_mapping, 'Application Mapping')) !== null && _b !== void 0 ? _b : {});
+    }
+}
+exports.FireHydrantConverter = FireHydrantConverter;

package/lib/converters/firehydrant/incidents.d.ts

@@ -0,0 +1,13 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { FireHydrantConverter } from './common';
+export declare class Incidents extends FireHydrantConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    private seenTags;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+    private getTaskDestinationRecord;
+    private getPriority;
+    private getSeverity;
+    private getIncidentStatus;
+    private getTaskStatus;
+}

package/lib/converters/firehydrant/incidents.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Incidents = void 0;
+const faros_feeds_sdk_1 = require("faros-feeds-sdk");
+const common_1 = require("./common");
+const models_1 = require("./models");
+class Incidents extends common_1.FireHydrantConverter {
+    constructor() {
+        super(...arguments);
+        this.destinationModels = [
+            'compute_Application',
+            'ims_Incident',
+            'ims_IncidentApplicationImpact',
+            'ims_IncidentAssignment',
+            'ims_IncidentEvent',
+            'ims_IncidentTag',
+            'ims_IncidentTasks',
+            'ims_Label',
+            'tms_Task',
+        ];
+        this.seenTags = new Set();
+    }
+    async convert(record, ctx) {
+        var _a, _b;
+        const source = this.streamName.source;
+        const incident = record.record.data;
+        const res = [];
+        const maxDescriptionLength = this.maxDescriptionLength(ctx);
+        const applicationMapping = this.applicationMapping(ctx);
+        const incidentRef = { uid: incident.id, source };
+        const createdAt = faros_feeds_sdk_1.Utils.toDate(incident.created_at);
+        const updatedAt = incident.events
+            ? faros_feeds_sdk_1.Utils.toDate(incident.events[incident.events.length - 1].occurred_at)
+            : createdAt;
+        let acknowledgedAt = undefined;
+        let resolvedAt = undefined;
+        for (const event of incident.events) {
+            const eventType = {
+                category: models_1.IncidentEventTypeCategory.Created,
+                detail: event.type,
+            };
+            const occurredAt = faros_feeds_sdk_1.Utils.toDate(event.occurred_at);
+            if (!resolvedAt &&
+                event.data.current_milestone === models_1.FirehydrantIncidentMilestone.resolved) {
+                resolvedAt = occurredAt;
+                eventType.category = models_1.IncidentEventTypeCategory.Resolved;
+            }
+            if (!acknowledgedAt &&
+                event.data.current_milestone ===
+                    models_1.FirehydrantIncidentMilestone.acknowledged) {
+                acknowledgedAt = occurredAt;
+                eventType.category = models_1.IncidentEventTypeCategory.Acknowledged;
+            }
+            res.push({
+                model: 'ims_IncidentEvent',
+                record: {
+                    uid: event.id,
+                    type: eventType,
+                    incident: incidentRef,
+                    detail: JSON.stringify(event.data),
+                    createdAt: occurredAt,
+                },
+            });
+            if (event.data.operation === 'created' && event.data.ticket) {
+                const ticket = event.data.ticket;
+                // TODO
+                res.push(this.getTaskDestinationRecord(ticket, source, maxDescriptionLength, occurredAt));
+                const task = { uid: ticket.id, source };
+                res.push({
+                    model: 'ims_IncidentTasks',
+                    record: {
+                        task,
+                        incident: incidentRef,
+                    },
+                });
+            }
+        }
+        res.push({
+            model: 'ims_Incident',
+            record: {
+                ...incidentRef,
+                title: incident.name,
+                description: (_a = incident.description) === null || _a === void 0 ? void 0 : _a.substring(0, maxDescriptionLength),
+                url: incident.incident_url,
+                createdAt,
+                updatedAt,
+                acknowledgedAt,
+                resolvedAt,
+                priority: this.getPriority(incident.priority),
+                severity: this.getSeverity(incident.severity),
+                status: this.getIncidentStatus(incident.current_milestone),
+            },
+        });
+        for (const service of incident.services) {
+            if (service.name in applicationMapping &&
+                applicationMapping[service.name].name) {
+                const mappedApp = applicationMapping[service.name];
+                const application = {
+                    name: mappedApp.name,
+                    platform: (_b = mappedApp.platform) !== null && _b !== void 0 ? _b : '',
+                };
+                res.push({ model: 'compute_Application', record: application });
+                res.push({
+                    model: 'ims_IncidentApplicationImpact',
+                    record: {
+                        incident: incidentRef,
+                        application,
+                    },
+                });
+            }
+        }
+        for (const assignment of incident.role_assignments) {
+            const assignee = { uid: assignment.user.id, source };
+            res.push({
+                model: 'ims_IncidentAssignment',
+                record: {
+                    assignee,
+                    incident: incidentRef,
+                },
+            });
+        }
+        for (const tag of incident.tag_list) {
+            if (!this.seenTags.has(tag)) {
+                this.seenTags.add(tag);
+                res.push({
+                    model: 'ims_Label',
+                    record: {
+                        name: tag,
+                    },
+                });
+            }
+            res.push({
+                model: 'ims_IncidentTag',
+                record: {
+                    label: { name: tag },
+                    incident: incidentRef,
+                },
+            });
+        }
+        return res;
+    }
+    getTaskDestinationRecord(ticket, source, maxDescriptionLength, occurredAt) {
+        var _a;
+        return {
+            model: 'tms_Task',
+            record: {
+                uid: ticket.id,
+                name: ticket.summary,
+                description: (_a = ticket.description) === null || _a === void 0 ? void 0 : _a.substring(0, maxDescriptionLength),
+                source,
+                url: undefined,
+                type: {
+                    detail: ticket.type,
+                    category: 'Task',
+                },
+                priority: undefined,
+                status: this.getTaskStatus(ticket.state),
+                points: 0,
+                additionalFields: [],
+                createdAt: occurredAt,
+                updatedAt: occurredAt,
+                statusChangedAt: undefined,
+                statusChangelog: undefined,
+                parent: undefined,
+                creator: { uid: ticket.created_by.id, source },
+                epic: undefined,
+                sprint: undefined,
+            },
+        };
+    }
+    getPriority(priority) {
+        const detail = priority;
+        switch (priority) {
+            case models_1.FirehydrantIncidentPriority.P1:
+                return { category: models_1.IncidentPriorityCategory.Critical, detail };
+            case models_1.FirehydrantIncidentPriority.P2:
+                return { category: models_1.IncidentPriorityCategory.High, detail };
+            case models_1.FirehydrantIncidentPriority.P3:
+                return { category: models_1.IncidentPriorityCategory.Medium, detail };
+            case models_1.FirehydrantIncidentPriority.P4:
+                return { category: models_1.IncidentPriorityCategory.Low, detail };
+            default:
+                return { category: models_1.IncidentPriorityCategory.Custom, detail };
+        }
+    }
+    getSeverity(severity) {
+        const detail = severity;
+        switch (severity) {
+            case models_1.FirehydrantIncidentSeverity.SEV1:
+                return { category: models_1.IncidentSeverityCategory.Sev1, detail };
+            case models_1.FirehydrantIncidentSeverity.SEV2:
+                return { category: models_1.IncidentSeverityCategory.Sev2, detail };
+            case models_1.FirehydrantIncidentSeverity.SEV3:
+                return { category: models_1.IncidentSeverityCategory.Sev3, detail };
+            case models_1.FirehydrantIncidentSeverity.SEV4:
+                return { category: models_1.IncidentSeverityCategory.Sev4, detail };
+            case models_1.FirehydrantIncidentSeverity.SEV5:
+                return { category: models_1.IncidentSeverityCategory.Sev5, detail };
+            default:
+                return { category: models_1.IncidentSeverityCategory.Custom, detail };
+        }
+    }
+    //https://support.firehydrant.io/hc/en-us/articles/4403969187604-Incident-Milestones
+    getIncidentStatus(milestone) {
+        const detail = milestone;
+        switch (milestone) {
+            case models_1.FirehydrantIncidentMilestone.started:
+                return { category: models_1.IncidentStatusCategory.Investigating, detail };
+            case models_1.FirehydrantIncidentMilestone.detected:
+                return { category: models_1.IncidentStatusCategory.Identified, detail };
+            case models_1.FirehydrantIncidentMilestone.acknowledged:
+            case models_1.FirehydrantIncidentMilestone.firstaction:
+                return { category: models_1.IncidentStatusCategory.Monitoring, detail };
+            case models_1.FirehydrantIncidentMilestone.mitigated:
+            case models_1.FirehydrantIncidentMilestone.resolved:
+                return { category: models_1.IncidentStatusCategory.Resolved, detail };
+            default:
+                return { category: models_1.IncidentStatusCategory.Custom, detail };
+        }
+    }
+    getTaskStatus(status) {
+        const detail = status;
+        switch (status) {
+            case models_1.IncidentTicketState.open:
+                return { category: models_1.TaskStatusCategory.Todo, detail };
+            case models_1.IncidentTicketState.in_progress:
+                return { category: models_1.TaskStatusCategory.InProgress, detail };
+            case models_1.IncidentTicketState.done:
+                return { category: models_1.TaskStatusCategory.Done, detail };
+            default:
+                return { category: models_1.TaskStatusCategory.Custom, detail };
+        }
+    }
+}
+exports.Incidents = Incidents;

package/lib/converters/firehydrant/models.d.ts

@@ -0,0 +1,212 @@
+interface ObjectBase {
+    id: string;
+    name: string;
+}
+interface IncidentRole extends ObjectBase {
+    summary: string;
+    description: string;
+    created_at: string;
+    updated_at: string;
+    discarded_at?: any;
+    tasks: [any];
+}
+interface Milestone {
+    id: string;
+    created_at: string;
+    updated_at: string;
+    type: string;
+    occurred_at: string;
+    duration: string;
+}
+export interface User extends ObjectBase {
+    email?: string;
+    created_at: string;
+    updated_at: string;
+    slack_linked?: boolean;
+}
+interface RoleAssignment {
+    id: string;
+    status: string;
+    created_at: string;
+    updated_at: string;
+    incident_role: IncidentRole;
+    user: User;
+    tasks: [any];
+}
+interface LastNote {
+    id: string;
+    body: string;
+    created_at: string;
+}
+interface Condition extends ObjectBase {
+    position: number;
+}
+interface Impact {
+    id: string;
+    type: string;
+    impact: ObjectBase;
+    condition: Condition;
+}
+interface CreatedBy extends ObjectBase {
+    source: string;
+    email: string;
+}
+export interface IncidentTicket {
+    id: string;
+    summary: string;
+    description?: any;
+    state: string;
+    type: string;
+    assignees: [any];
+    created_by: CreatedBy;
+    attachments: [any];
+}
+export interface IncidentEvent {
+    id: string;
+    incident_id: string;
+    occurred_at: string;
+    type: string;
+    visibility: string;
+    author: User;
+    data: any;
+}
+export interface Incident extends ObjectBase {
+    created_at: string;
+    started_at: string;
+    summary: string;
+    customer_impact_summary: string;
+    description: string;
+    current_milestone: string;
+    number: number;
+    priority: string;
+    severity: string;
+    severity_impact?: any;
+    severity_condition?: any;
+    tag_list: [string];
+    private_id: string;
+    organization_id: string;
+    incident_roles: [IncidentRole];
+    milestones: [Milestone];
+    active: boolean;
+    labels: Record<string, string>;
+    role_assignments: [RoleAssignment];
+    status_pages: [any];
+    incident_url: string;
+    private_status_page_url: string;
+    organization: ObjectBase;
+    customers_impacted: number;
+    monetary_impact?: any;
+    monetary_impact_cents?: any;
+    last_update: string;
+    last_note: LastNote;
+    report_id?: any;
+    services: ObjectBase[];
+    environments: ObjectBase[];
+    functionalities: ObjectBase[];
+    channel_name?: any;
+    channel_reference?: any;
+    channel_id?: any;
+    channel_status?: any;
+    incident_tickets: [IncidentTicket];
+    impacts: [Impact];
+    conference_bridges: [any];
+    incident_channels: [any];
+    retro_s: [any];
+    created_by: CreatedBy;
+    context_object?: any;
+    restricted: boolean;
+    explicit_organization_user_ids: [any];
+    events: IncidentEvent[];
+}
+interface TeamMember {
+    user: User;
+    default_incident_role: IncidentRole;
+}
+export interface Team extends ObjectBase {
+    description?: string;
+    slug?: string;
+    created_at: string;
+    updated_at: string;
+    memberships: [TeamMember];
+}
+export declare enum IncidentEventTypeCategory {
+    Created = "Created",
+    Acknowledged = "Acknowledged",
+    Resolved = "Resolved",
+    Custom = "Custom"
+}
+export interface IncidentEventType {
+    category: IncidentEventTypeCategory;
+    detail: string;
+}
+export declare enum FirehydrantIncidentPriority {
+    P1 = "P1",
+    P2 = "P2",
+    P3 = "P3",
+    P4 = "P4"
+}
+export declare enum FirehydrantIncidentMilestone {
+    started = "started",
+    detected = "detected",
+    acknowledged = "acknowledged",
+    firstaction = "firstaction",
+    mitigated = "mitigated",
+    resolved = "resolved"
+}
+export declare enum FirehydrantIncidentSeverity {
+    SEV1 = "SEV1",
+    SEV2 = "SEV2",
+    SEV3 = "SEV3",
+    SEV4 = "SEV4",
+    SEV5 = "SEV5",
+    GAMEDAY = "GAMEDAY",
+    MAINTENANCE = "MAINTENANCE",
+    UNSET = "UNSET"
+}
+export declare enum IncidentStatusCategory {
+    Identified = "Identified",
+    Investigating = "Investigating",
+    Monitoring = "Monitoring",
+    Resolved = "Resolved",
+    Custom = "Custom"
+}
+export interface IncidentPriority {
+    category: IncidentPriorityCategory;
+    detail: string;
+}
+export declare enum IncidentPriorityCategory {
+    Critical = "Critical",
+    High = "High",
+    Medium = "Medium",
+    Low = "Low",
+    Custom = "Custom"
+}
+export declare enum IncidentSeverityCategory {
+    Sev1 = "Sev1",
+    Sev2 = "Sev2",
+    Sev3 = "Sev3",
+    Sev4 = "Sev4",
+    Sev5 = "Sev5",
+    Custom = "Custom"
+}
+export interface IncidentSeverity {
+    category: IncidentSeverityCategory;
+    detail: string;
+}
+export declare enum IncidentTicketState {
+    open = "open",
+    in_progress = "in_progress",
+    cancelled = "cancelled",
+    done = "done"
+}
+export interface TaskStatus {
+    category: TaskStatusCategory;
+    detail: string;
+}
+export declare enum TaskStatusCategory {
+    Custom = "Custom",
+    Done = "Done",
+    InProgress = "InProgress",
+    Todo = "Todo"
+}
+export {};

package/lib/converters/firehydrant/models.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStatusCategory = exports.IncidentTicketState = exports.IncidentSeverityCategory = exports.IncidentPriorityCategory = exports.IncidentStatusCategory = exports.FirehydrantIncidentSeverity = exports.FirehydrantIncidentMilestone = exports.FirehydrantIncidentPriority = exports.IncidentEventTypeCategory = void 0;
+var IncidentEventTypeCategory;
+(function (IncidentEventTypeCategory) {
+    IncidentEventTypeCategory["Created"] = "Created";
+    IncidentEventTypeCategory["Acknowledged"] = "Acknowledged";
+    IncidentEventTypeCategory["Resolved"] = "Resolved";
+    IncidentEventTypeCategory["Custom"] = "Custom";
+})(IncidentEventTypeCategory = exports.IncidentEventTypeCategory || (exports.IncidentEventTypeCategory = {}));
+var FirehydrantIncidentPriority;
+(function (FirehydrantIncidentPriority) {
+    FirehydrantIncidentPriority["P1"] = "P1";
+    FirehydrantIncidentPriority["P2"] = "P2";
+    FirehydrantIncidentPriority["P3"] = "P3";
+    FirehydrantIncidentPriority["P4"] = "P4";
+})(FirehydrantIncidentPriority = exports.FirehydrantIncidentPriority || (exports.FirehydrantIncidentPriority = {}));
+var FirehydrantIncidentMilestone;
+(function (FirehydrantIncidentMilestone) {
+    FirehydrantIncidentMilestone["started"] = "started";
+    FirehydrantIncidentMilestone["detected"] = "detected";
+    FirehydrantIncidentMilestone["acknowledged"] = "acknowledged";
+    FirehydrantIncidentMilestone["firstaction"] = "firstaction";
+    FirehydrantIncidentMilestone["mitigated"] = "mitigated";
+    FirehydrantIncidentMilestone["resolved"] = "resolved";
+})(FirehydrantIncidentMilestone = exports.FirehydrantIncidentMilestone || (exports.FirehydrantIncidentMilestone = {}));
+var FirehydrantIncidentSeverity;
+(function (FirehydrantIncidentSeverity) {
+    FirehydrantIncidentSeverity["SEV1"] = "SEV1";
+    FirehydrantIncidentSeverity["SEV2"] = "SEV2";
+    FirehydrantIncidentSeverity["SEV3"] = "SEV3";
+    FirehydrantIncidentSeverity["SEV4"] = "SEV4";
+    FirehydrantIncidentSeverity["SEV5"] = "SEV5";
+    FirehydrantIncidentSeverity["GAMEDAY"] = "GAMEDAY";
+    FirehydrantIncidentSeverity["MAINTENANCE"] = "MAINTENANCE";
+    FirehydrantIncidentSeverity["UNSET"] = "UNSET";
+})(FirehydrantIncidentSeverity = exports.FirehydrantIncidentSeverity || (exports.FirehydrantIncidentSeverity = {}));
+var IncidentStatusCategory;
+(function (IncidentStatusCategory) {
+    IncidentStatusCategory["Identified"] = "Identified";
+    IncidentStatusCategory["Investigating"] = "Investigating";
+    IncidentStatusCategory["Monitoring"] = "Monitoring";
+    IncidentStatusCategory["Resolved"] = "Resolved";
+    IncidentStatusCategory["Custom"] = "Custom";
+})(IncidentStatusCategory = exports.IncidentStatusCategory || (exports.IncidentStatusCategory = {}));
+var IncidentPriorityCategory;
+(function (IncidentPriorityCategory) {
+    IncidentPriorityCategory["Critical"] = "Critical";
+    IncidentPriorityCategory["High"] = "High";
+    IncidentPriorityCategory["Medium"] = "Medium";
+    IncidentPriorityCategory["Low"] = "Low";
+    IncidentPriorityCategory["Custom"] = "Custom";
+})(IncidentPriorityCategory = exports.IncidentPriorityCategory || (exports.IncidentPriorityCategory = {}));
+var IncidentSeverityCategory;
+(function (IncidentSeverityCategory) {
+    IncidentSeverityCategory["Sev1"] = "Sev1";
+    IncidentSeverityCategory["Sev2"] = "Sev2";
+    IncidentSeverityCategory["Sev3"] = "Sev3";
+    IncidentSeverityCategory["Sev4"] = "Sev4";
+    IncidentSeverityCategory["Sev5"] = "Sev5";
+    IncidentSeverityCategory["Custom"] = "Custom";
+})(IncidentSeverityCategory = exports.IncidentSeverityCategory || (exports.IncidentSeverityCategory = {}));
+var IncidentTicketState;
+(function (IncidentTicketState) {
+    IncidentTicketState["open"] = "open";
+    IncidentTicketState["in_progress"] = "in_progress";
+    IncidentTicketState["cancelled"] = "cancelled";
+    IncidentTicketState["done"] = "done";
+})(IncidentTicketState = exports.IncidentTicketState || (exports.IncidentTicketState = {}));
+var TaskStatusCategory;
+(function (TaskStatusCategory) {
+    TaskStatusCategory["Custom"] = "Custom";
+    TaskStatusCategory["Done"] = "Done";
+    TaskStatusCategory["InProgress"] = "InProgress";
+    TaskStatusCategory["Todo"] = "Todo";
+})(TaskStatusCategory = exports.TaskStatusCategory || (exports.TaskStatusCategory = {}));

package/lib/converters/firehydrant/teams.d.ts

@@ -0,0 +1,7 @@
+import { AirbyteRecord } from 'faros-airbyte-cdk';
+import { DestinationModel, DestinationRecord, StreamContext } from '../converter';
+import { FireHydrantConverter } from './common';
+export declare class Teams extends FireHydrantConverter {
+    readonly destinationModels: ReadonlyArray<DestinationModel>;
+    convert(record: AirbyteRecord, ctx: StreamContext): Promise<ReadonlyArray<DestinationRecord>>;
+}