checkly 0.0.0-pr.686.4c0f5e3

package/dist/commands/whoami.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"whoami.js","sourceRoot":"","sources":["../../src/commands/whoami.ts"],"names":[],"mappings":";;AAAA,+CAAuC;AACvC,mCAAkC;AAClC,+CAA2C;AAE3C,MAAqB,MAAO,SAAQ,yBAAW;IAG7C,KAAK,CAAC,GAAG;QACP,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,gBAAM,CAAC,YAAY,EAAE,CAAC,CAAA;QACvE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE,CAAA;QAC3C,IAAI,CAAC,GAAG,CAAC,iCAAiC,OAAO,CAAC,IAAI,MAAM,OAAO,CAAC,EAAE,QAAQ,IAAI,CAAC,IAAI,GAAG,CAAC,CAAA;IAC7F,CAAC;;AAPH,yBAQC;AAPQ,aAAM,GAAG,KAAK,CAAA;AACd,kBAAW,GAAG,gDAAgD,CAAA"}

package/dist/config.d.ts

@@ -0,0 +1,31 @@
+import type { ChecklyConfig } from './services/checkly-config-loader';
+/**
+ *  Supported regions
+ */
+declare module './' {
+    interface Region {
+        'us-east-1': string;
+        'us-east-2': string;
+        'us-west-1': string;
+        'us-west-2': string;
+        'ca-central-1': string;
+        'sa-east-1': string;
+        'eu-west-1': string;
+        'eu-central-1': string;
+        'eu-west-2': string;
+        'eu-west-3': string;
+        'eu-north-1': string;
+        'eu-south-1': string;
+        'me-south-1': string;
+        'ap-southeast-1': string;
+        'ap-northeast-1': string;
+        'ap-east-1': string;
+        'ap-southeast-2': string;
+        'ap-southeast-3': string;
+        'ap-northeast-2': string;
+        'ap-northeast-3': string;
+        'ap-south-1': string;
+        'af-south-1': string;
+    }
+}
+export declare function defineConfig(config: ChecklyConfig): ChecklyConfig;

package/dist/config.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = void 0;
+function defineConfig(config) {
+    return config;
+}
+exports.defineConfig = defineConfig;
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;;AAiCA,SAAgB,YAAY,CAAE,MAAqB;IACjD,OAAO,MAAM,CAAA;AACf,CAAC;AAFD,oCAEC"}

package/dist/constructs/alert-channel-subscription.d.ts

@@ -0,0 +1,44 @@
+import { Ref } from './ref';
+import { Construct } from './construct';
+export interface AlertChannelSubscriptionProps {
+    alertChannelId: Ref;
+    /**
+     * You can either pass a checkId or a groupId, but not both.
+     */
+    checkId?: Ref;
+    /**
+     * You can either pass a groupId or a checkId, but not both.
+     */
+    groupId?: Ref;
+    /**
+     *  Determines if the suscription active or not.
+     */
+    activated: boolean;
+}
+/**
+ * Creates an Alert Channel Subscription
+ *
+ * @remarks
+ *
+ * This class make use of the Alert Channel Subscriptions endpoints.
+ */
+export declare class AlertChannelSubscription extends Construct {
+    alertChannelId: Ref;
+    checkId?: Ref;
+    groupId?: Ref;
+    activated: boolean;
+    static readonly __checklyType = "alert-channel-subscription";
+    /**
+     * Constructs the Alert Channel Syscription instance
+     *
+     * @param logicalId unique project-scoped resource name identification
+     * @param props alert channel subscription configuration properties
+     */
+    constructor(logicalId: string, props: AlertChannelSubscriptionProps);
+    synthesize(): {
+        alertChannelId: Ref;
+        checkId: Ref | undefined;
+        groupId: Ref | undefined;
+        activated: boolean;
+    };
+}

package/dist/constructs/alert-channel-subscription.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertChannelSubscription = void 0;
+const construct_1 = require("./construct");
+const project_1 = require("./project");
+/**
+ * Creates an Alert Channel Subscription
+ *
+ * @remarks
+ *
+ * This class make use of the Alert Channel Subscriptions endpoints.
+ */
+class AlertChannelSubscription extends construct_1.Construct {
+    /**
+     * Constructs the Alert Channel Syscription instance
+     *
+     * @param logicalId unique project-scoped resource name identification
+     * @param props alert channel subscription configuration properties
+     */
+    constructor(logicalId, props) {
+        super(AlertChannelSubscription.__checklyType, logicalId);
+        this.alertChannelId = props.alertChannelId;
+        this.checkId = props.checkId;
+        this.groupId = props.groupId;
+        this.activated = props.activated;
+        project_1.Session.registerConstruct(this);
+    }
+    synthesize() {
+        return {
+            alertChannelId: this.alertChannelId,
+            checkId: this.checkId,
+            groupId: this.groupId,
+            activated: this.activated,
+        };
+    }
+}
+exports.AlertChannelSubscription = AlertChannelSubscription;
+AlertChannelSubscription.__checklyType = 'alert-channel-subscription';
+//# sourceMappingURL=alert-channel-subscription.js.map

package/dist/constructs/alert-channel-subscription.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alert-channel-subscription.js","sourceRoot":"","sources":["../../src/constructs/alert-channel-subscription.ts"],"names":[],"mappings":";;;AACA,2CAAuC;AACvC,uCAAmC;AAkBnC;;;;;;GAMG;AACH,MAAa,wBAAyB,SAAQ,qBAAS;IAQrD;;;;;OAKG;IACH,YAAa,SAAiB,EAAE,KAAoC;QAClE,KAAK,CAAC,wBAAwB,CAAC,aAAa,EAAE,SAAS,CAAC,CAAA;QACxD,IAAI,CAAC,cAAc,GAAG,KAAK,CAAC,cAAc,CAAA;QAC1C,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAA;QAC5B,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAA;QAC5B,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAA;QAChC,iBAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAA;IACjC,CAAC;IAED,UAAU;QACR,OAAO;YACL,cAAc,EAAE,IAAI,CAAC,cAAc;YACnC,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,SAAS,EAAE,IAAI,CAAC,SAAS;SAC1B,CAAA;IACH,CAAC;;AA9BH,4DA+BC;AAzBiB,sCAAa,GAAG,4BAA4B,CAAA"}

package/dist/constructs/alert-channel.d.ts

@@ -0,0 +1,53 @@
+import { Construct } from './construct';
+export interface AlertChannelProps {
+    /**
+     * Determines if an alert should be send for check recoveries.
+     */
+    sendRecovery?: boolean;
+    /**
+     * Determines if an alert should be send for check failures.
+     */
+    sendFailure?: boolean;
+    /**
+     * Determines if an alert should be send when a check is degraded.
+     */
+    sendDegraded?: boolean;
+    /**
+     * Determines if an alert should be send for expiring SSL certificates.
+     */
+    sslExpiry?: boolean;
+    /**
+     * At what moment in time to start alerting on SSL certificates.
+     */
+    sslExpiryThreshold?: number;
+}
+declare class AlertChannelWrapper extends Construct {
+    constructor(logicalId: string, physicalId: string | number);
+    synthesize(): null;
+}
+/**
+ * Creates an Alert Channels
+ *
+ * @remarks
+ *
+ * This class make use of the Alert Channels endpoints.
+ */
+export declare abstract class AlertChannel extends Construct {
+    sendRecovery?: boolean;
+    sendFailure?: boolean;
+    sendDegraded?: boolean;
+    sslExpiry?: boolean;
+    sslExpiryThreshold?: number;
+    static readonly __checklyType = "alert-channel";
+    /**
+     * Constructs the Alert Channel instance
+     *
+     * @param logicalId unique project-scoped resource name identification
+     * @param props alert channel configuration properties
+     */
+    constructor(logicalId: string, props: AlertChannelProps);
+    static fromId(id: string | number): AlertChannelWrapper;
+    allowInChecklyConfig(): boolean;
+    synthesize(): any | null;
+}
+export {};

package/dist/constructs/alert-channel.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlertChannel = void 0;
+const construct_1 = require("./construct");
+const project_1 = require("./project");
+class AlertChannelWrapper extends construct_1.Construct {
+    constructor(logicalId, physicalId) {
+        super(AlertChannel.__checklyType, logicalId, physicalId, false);
+        project_1.Session.registerConstruct(this);
+    }
+    synthesize() {
+        return null;
+    }
+}
+/**
+ * Creates an Alert Channels
+ *
+ * @remarks
+ *
+ * This class make use of the Alert Channels endpoints.
+ */
+class AlertChannel extends construct_1.Construct {
+    /**
+     * Constructs the Alert Channel instance
+     *
+     * @param logicalId unique project-scoped resource name identification
+     * @param props alert channel configuration properties
+     */
+    constructor(logicalId, props) {
+        super(AlertChannel.__checklyType, logicalId);
+        this.sendRecovery = props.sendRecovery;
+        this.sendFailure = props.sendFailure;
+        this.sendDegraded = props.sendDegraded;
+        this.sslExpiry = props.sslExpiry;
+        this.sslExpiryThreshold = props.sslExpiryThreshold;
+    }
+    static fromId(id) {
+        return new AlertChannelWrapper(`alert-channel-${id}`, id);
+    }
+    allowInChecklyConfig() {
+        return true;
+    }
+    synthesize() {
+        return {
+            sendRecovery: this.sendRecovery,
+            sendFailure: this.sendFailure,
+            sendDegraded: this.sendDegraded,
+            sslExpiry: this.sslExpiry,
+            sslExpiryThreshold: this.sslExpiryThreshold,
+        };
+    }
+}
+exports.AlertChannel = AlertChannel;
+AlertChannel.__checklyType = 'alert-channel';
+//# sourceMappingURL=alert-channel.js.map

package/dist/constructs/alert-channel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alert-channel.js","sourceRoot":"","sources":["../../src/constructs/alert-channel.ts"],"names":[],"mappings":";;;AAAA,2CAAuC;AACvC,uCAAmC;AAyBnC,MAAM,mBAAoB,SAAQ,qBAAS;IACzC,YAAa,SAAiB,EAAE,UAAyB;QACvD,KAAK,CAAC,YAAY,CAAC,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,KAAK,CAAC,CAAA;QAC/D,iBAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAA;IACjC,CAAC;IAED,UAAU;QACR,OAAO,IAAI,CAAA;IACb,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAsB,YAAa,SAAQ,qBAAS;IASlD;;;;;OAKG;IACH,YAAa,SAAiB,EAAE,KAAwB;QACtD,KAAK,CAAC,YAAY,CAAC,aAAa,EAAE,SAAS,CAAC,CAAA;QAC5C,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAA;QACtC,IAAI,CAAC,WAAW,GAAG,KAAK,CAAC,WAAW,CAAA;QACpC,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAA;QACtC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAA;QAChC,IAAI,CAAC,kBAAkB,GAAG,KAAK,CAAC,kBAAkB,CAAA;IACpD,CAAC;IAED,MAAM,CAAC,MAAM,CAAE,EAAiB;QAC9B,OAAO,IAAI,mBAAmB,CAAC,iBAAiB,EAAE,EAAE,EAAE,EAAE,CAAC,CAAA;IAC3D,CAAC;IAED,oBAAoB;QAClB,OAAO,IAAI,CAAA;IACb,CAAC;IAED,UAAU;QACR,OAAO;YACL,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,YAAY,EAAE,IAAI,CAAC,YAAY;YAC/B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,kBAAkB,EAAE,IAAI,CAAC,kBAAkB;SAC5C,CAAA;IACH,CAAC;;AAxCH,oCAyCC;AAlCiB,0BAAa,GAAG,eAAe,CAAA"}

package/dist/constructs/api-check.d.ts

@@ -0,0 +1,179 @@
+import { Check, CheckProps } from './check';
+import { HttpHeader } from './http-header';
+import { QueryParam } from './query-param';
+import { Content, Entrypoint } from './construct';
+declare enum AssertionSource {
+    STATUS_CODE = "STATUS_CODE",
+    JSON_BODY = "JSON_BODY",
+    HEADERS = "HEADERS",
+    TEXT_BODY = "TEXT_BODY",
+    RESPONSE_TIME = "RESPONSE_TIME"
+}
+export interface Assertion {
+    source: string;
+    property: string;
+    comparison: string;
+    target: string;
+    regex: string | null;
+}
+export declare class AssertionBuilder {
+    static statusCode(): NumericAssertionBuilder;
+    static jsonBody(property?: string): GeneralAssertionBuilder;
+    static headers(property?: string, regex?: string): GeneralAssertionBuilder;
+    static textBody(property?: string): GeneralAssertionBuilder;
+    static responseTme(): NumericAssertionBuilder;
+}
+declare class NumericAssertionBuilder {
+    source: AssertionSource;
+    constructor(source: AssertionSource);
+    equals(target: number): Assertion;
+    notEquals(target: number): Assertion;
+    lessThan(target: number): Assertion;
+    greaterThan(target: number): Assertion;
+    /** @private */
+    private _toAssertion;
+}
+declare class GeneralAssertionBuilder {
+    source: AssertionSource;
+    property?: string;
+    regex?: string;
+    constructor(source: AssertionSource, property?: string, regex?: string);
+    equals(target: string | number | boolean): Assertion;
+    notEquals(target: string | number | boolean): Assertion;
+    hasKey(target: string): Assertion;
+    notHasKey(target: string): Assertion;
+    hasValue(target: string | number | boolean): Assertion;
+    notHasValue(target: string | number | boolean): Assertion;
+    isEmpty(): Assertion;
+    notEmpty(): Assertion;
+    lessThan(target: string | number | boolean): Assertion;
+    greaterThan(target: string | number | boolean): Assertion;
+    contains(target: string): Assertion;
+    notContains(target: string): Assertion;
+    isNull(): Assertion;
+    isNotNull(): Assertion;
+    /** @private */
+    private _toAssertion;
+}
+export type BodyType = 'JSON' | 'FORM' | 'RAW' | 'GRAPHQL' | 'NONE';
+export type HttpRequestMethod = 'get' | 'GET' | 'post' | 'POST' | 'put' | 'PUT' | 'patch' | 'PATCH' | 'head' | 'HEAD' | 'delete' | 'DELETE' | 'options' | 'OPTIONS';
+export interface BasicAuth {
+    username: string;
+    password: string;
+}
+export type ApiCheckDefaultConfig = {
+    url?: string;
+    headers?: Array<HttpHeader>;
+    queryParameters?: Array<QueryParam>;
+    basicAuth?: BasicAuth;
+};
+export interface Request {
+    url: string;
+    method: HttpRequestMethod;
+    followRedirects?: boolean;
+    skipSSL?: boolean;
+    /**
+     * Check the main Checkly documentation on assertions for specific values like regular expressions
+     * and JSON path descriptors you can use in the "property" field.
+     */
+    assertions?: Array<Assertion>;
+    body?: string;
+    bodyType?: BodyType;
+    headers?: Array<HttpHeader>;
+    queryParameters?: Array<QueryParam>;
+    basicAuth?: BasicAuth;
+}
+export interface ScriptDependency {
+    path: string;
+    content: string;
+}
+export interface ApiCheckProps extends CheckProps {
+    /**
+     *  Determines the request that the check is going to run.
+     */
+    request: Request;
+    /**
+     * A valid piece of Node.js code to run in the setup phase.
+     * @deprecated use the "setupScript" property instead
+     */
+    localSetupScript?: string;
+    /**
+     * A valid piece of Node.js code to run in the setup phase.
+     */
+    setupScript?: Content | Entrypoint;
+    /**
+     * A valid piece of Node.js code to run in the teardown phase.
+     * @deprecated use the "tearDownScript" property instead
+     */
+    localTearDownScript?: string;
+    /**
+     * A valid piece of Node.js code to run in the teardown phase.
+     */
+    tearDownScript?: Content | Entrypoint;
+    /**
+     * The response time in milliseconds where a check should be considered degraded.
+     */
+    degradedResponseTime?: number;
+    /**
+     * The response time in milliseconds where a check should be considered failing.
+     */
+    maxResponseTime?: number;
+}
+/**
+ * Creates an API Check
+ *
+ * @remarks
+ *
+ * This class make use of the API Checks endpoints.
+ */
+export declare class ApiCheck extends Check {
+    request: Request;
+    localSetupScript?: string;
+    localTearDownScript?: string;
+    degradedResponseTime?: number;
+    maxResponseTime?: number;
+    private readonly setupScriptDependencies?;
+    private readonly tearDownScriptDependencies?;
+    private readonly setupScriptPath?;
+    private readonly tearDownScriptPath?;
+    /**
+     * Constructs the API Check instance
+     *
+     * @param logicalId unique project-scoped resource name identification
+     * @param props check configuration properties
+     *
+     * {@link https://checklyhq.com/docs/cli/constructs/#apicheck Read more in the docs}
+     */
+    constructor(logicalId: string, props: ApiCheckProps);
+    static bundle(entrypoint: string, runtimeId: string): {
+        script: string;
+        scriptPath: string;
+        dependencies: ScriptDependency[];
+    };
+    synthesize(): {
+        checkType: string;
+        request: Request;
+        localSetupScript: string | undefined;
+        setupScriptPath: string | undefined;
+        setupScriptDependencies: ScriptDependency[] | undefined;
+        localTearDownScript: string | undefined;
+        tearDownScriptPath: string | undefined;
+        tearDownScriptDependencies: ScriptDependency[] | undefined;
+        degradedResponseTime: number | undefined;
+        maxResponseTime: number | undefined;
+        name: string;
+        activated: boolean | undefined;
+        muted: boolean | undefined;
+        doubleCheck: boolean | undefined;
+        shouldFail: boolean | undefined;
+        runtimeId: string | undefined;
+        locations: (keyof import("..").Region)[] | undefined;
+        privateLocations: string[] | undefined;
+        tags: string[] | undefined;
+        frequency: number | undefined;
+        frequencyOffset: number | undefined;
+        groupId: import("./ref").Ref | undefined;
+        environmentVariables: import("./key-value-pair").default[] | undefined;
+    };
+}
+export {};

package/dist/constructs/api-check.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiCheck = exports.AssertionBuilder = void 0;
+const path = require("path");
+const check_1 = require("./check");
+const project_1 = require("./project");
+const parser_1 = require("../services/check-parser/parser");
+const util_1 = require("../services/util");
+const util_2 = require("../reporters/util");
+// eslint-disable-next-line no-restricted-syntax
+var AssertionSource;
+(function (AssertionSource) {
+    AssertionSource["STATUS_CODE"] = "STATUS_CODE";
+    AssertionSource["JSON_BODY"] = "JSON_BODY";
+    AssertionSource["HEADERS"] = "HEADERS";
+    AssertionSource["TEXT_BODY"] = "TEXT_BODY";
+    AssertionSource["RESPONSE_TIME"] = "RESPONSE_TIME";
+})(AssertionSource || (AssertionSource = {}));
+// eslint-disable-next-line no-restricted-syntax
+var AssertionComparison;
+(function (AssertionComparison) {
+    AssertionComparison["EQUALS"] = "EQUALS";
+    AssertionComparison["NOT_EQUALS"] = "NOT_EQUALS";
+    AssertionComparison["HAS_KEY"] = "HAS_KEY";
+    AssertionComparison["NOT_HAS_KEY"] = "NOT_HAS_KEY";
+    AssertionComparison["HAS_VALUE"] = "HAS_VALUE";
+    AssertionComparison["NOT_HAS_VALUE"] = "NOT_HAS_VALUE";
+    AssertionComparison["IS_EMPTY"] = "IS_EMPTY";
+    AssertionComparison["NOT_EMPTY"] = "NOT_EMPTY";
+    AssertionComparison["GREATER_THAN"] = "GREATER_THAN";
+    AssertionComparison["LESS_THAN"] = "LESS_THAN";
+    AssertionComparison["CONTAINS"] = "CONTAINS";
+    AssertionComparison["NOT_CONTAINS"] = "NOT_CONTAINS";
+    AssertionComparison["IS_NULL"] = "IS_NULL";
+    AssertionComparison["NOT_NULL"] = "NOT_NULL";
+})(AssertionComparison || (AssertionComparison = {}));
+class AssertionBuilder {
+    static statusCode() {
+        return new NumericAssertionBuilder(AssertionSource.STATUS_CODE);
+    }
+    static jsonBody(property) {
+        return new GeneralAssertionBuilder(AssertionSource.JSON_BODY, property);
+    }
+    static headers(property, regex) {
+        return new GeneralAssertionBuilder(AssertionSource.HEADERS, property, regex);
+    }
+    static textBody(property) {
+        return new GeneralAssertionBuilder(AssertionSource.TEXT_BODY, property);
+    }
+    static responseTme() {
+        return new NumericAssertionBuilder(AssertionSource.RESPONSE_TIME);
+    }
+}
+exports.AssertionBuilder = AssertionBuilder;
+class NumericAssertionBuilder {
+    constructor(source) {
+        this.source = source;
+    }
+    equals(target) {
+        return this._toAssertion(AssertionComparison.EQUALS, target);
+    }
+    notEquals(target) {
+        return this._toAssertion(AssertionComparison.NOT_EQUALS, target);
+    }
+    lessThan(target) {
+        return this._toAssertion(AssertionComparison.LESS_THAN, target);
+    }
+    greaterThan(target) {
+        return this._toAssertion(AssertionComparison.GREATER_THAN, target);
+    }
+    /** @private */
+    _toAssertion(comparison, target) {
+        return { source: this.source, comparison, property: '', target: target.toString(), regex: null };
+    }
+}
+class GeneralAssertionBuilder {
+    constructor(source, property, regex) {
+        this.source = source;
+        this.property = property;
+        this.regex = regex;
+    }
+    equals(target) {
+        return this._toAssertion(AssertionComparison.EQUALS, target);
+    }
+    notEquals(target) {
+        return this._toAssertion(AssertionComparison.NOT_EQUALS, target);
+    }
+    hasKey(target) {
+        return this._toAssertion(AssertionComparison.HAS_KEY, target);
+    }
+    notHasKey(target) {
+        return this._toAssertion(AssertionComparison.NOT_HAS_KEY, target);
+    }
+    hasValue(target) {
+        return this._toAssertion(AssertionComparison.HAS_VALUE, target);
+    }
+    notHasValue(target) {
+        return this._toAssertion(AssertionComparison.NOT_HAS_VALUE, target);
+    }
+    isEmpty() {
+        return this._toAssertion(AssertionComparison.IS_EMPTY);
+    }
+    notEmpty() {
+        return this._toAssertion(AssertionComparison.NOT_EMPTY);
+    }
+    lessThan(target) {
+        return this._toAssertion(AssertionComparison.LESS_THAN, target);
+    }
+    greaterThan(target) {
+        return this._toAssertion(AssertionComparison.GREATER_THAN, target);
+    }
+    contains(target) {
+        return this._toAssertion(AssertionComparison.CONTAINS, target);
+    }
+    notContains(target) {
+        return this._toAssertion(AssertionComparison.CONTAINS, target);
+    }
+    isNull() {
+        return this._toAssertion(AssertionComparison.IS_NULL);
+    }
+    isNotNull() {
+        return this._toAssertion(AssertionComparison.NOT_NULL);
+    }
+    /** @private */
+    _toAssertion(comparison, target) {
+        var _a, _b, _c;
+        return {
+            source: this.source,
+            comparison,
+            property: (_a = this.property) !== null && _a !== void 0 ? _a : '',
+            target: (_b = target === null || target === void 0 ? void 0 : target.toString()) !== null && _b !== void 0 ? _b : '',
+            regex: (_c = this.regex) !== null && _c !== void 0 ? _c : null,
+        };
+    }
+}
+function _printWarning(path) {
+    (0, util_2.printDeprecationWarning)(`API check "${path}" is probably providing a setup ` +
+        'or tearDown script using the "localSetupScript" or "localTearDownScript" property. Please update your API checks to ' +
+        'reference any setup / tearDown using the "setupScript" and "tearDownScript" properties See the docs at ' +
+        'https://checklyhq.com/docs/cli/constructs-reference#apicheck');
+}
+/**
+ * Creates an API Check
+ *
+ * @remarks
+ *
+ * This class make use of the API Checks endpoints.
+ */
+class ApiCheck extends check_1.Check {
+    /**
+     * Constructs the API Check instance
+     *
+     * @param logicalId unique project-scoped resource name identification
+     * @param props check configuration properties
+     *
+     * {@link https://checklyhq.com/docs/cli/constructs/#apicheck Read more in the docs}
+     */
+    constructor(logicalId, props) {
+        super(logicalId, props);
+        if (props.setupScript) {
+            if ('entrypoint' in props.setupScript) {
+                const { script, scriptPath, dependencies } = ApiCheck.bundle(props.setupScript.entrypoint, this.runtimeId);
+                this.localSetupScript = script;
+                this.setupScriptPath = scriptPath;
+                this.setupScriptDependencies = dependencies;
+            }
+            else if ('content' in props.setupScript) {
+                this.localSetupScript = props.setupScript.content;
+            }
+            else {
+                throw new Error('Unrecognized type for the "setupScript" property. A "setupScript" should have either a "content" ' +
+                    'or "entrypoint" property.');
+            }
+        }
+        if (props.localSetupScript) {
+            _printWarning(project_1.Session.checkFilePath);
+            this.localSetupScript = props.localSetupScript;
+        }
+        if (props.tearDownScript) {
+            if ('entrypoint' in props.tearDownScript) {
+                const { script, scriptPath, dependencies } = ApiCheck.bundle(props.tearDownScript.entrypoint, this.runtimeId);
+                this.localTearDownScript = script;
+                this.tearDownScriptPath = scriptPath;
+                this.tearDownScriptDependencies = dependencies;
+            }
+            else if ('content' in props.tearDownScript) {
+                this.localTearDownScript = props.tearDownScript.content;
+            }
+        }
+        if (props.localTearDownScript) {
+            _printWarning(project_1.Session.checkFilePath);
+            this.localTearDownScript = props.localTearDownScript;
+        }
+        this.request = props.request;
+        this.degradedResponseTime = props.degradedResponseTime;
+        this.maxResponseTime = props.maxResponseTime;
+        project_1.Session.registerConstruct(this);
+        this.addSubscriptions();
+    }
+    static bundle(entrypoint, runtimeId) {
+        let absoluteEntrypoint = null;
+        if (path.isAbsolute(entrypoint)) {
+            absoluteEntrypoint = entrypoint;
+        }
+        else {
+            if (!project_1.Session.checkFileAbsolutePath) {
+                throw new Error('You cant use relative paths without the checkFileAbsolutePath in session');
+            }
+            absoluteEntrypoint = path.join(path.dirname(project_1.Session.checkFileAbsolutePath), entrypoint);
+        }
+        const runtime = project_1.Session.availableRuntimes[runtimeId];
+        if (!runtime) {
+            throw new Error(`${runtimeId} is not supported`);
+        }
+        const parser = new parser_1.Parser(Object.keys(runtime.dependencies));
+        const parsed = parser.parse(absoluteEntrypoint);
+        // Maybe we can get the parsed deps with the content immediately
+        const deps = [];
+        for (const { filePath, content } of parsed.dependencies) {
+            deps.push({
+                path: (0, util_1.pathToPosix)(path.relative(project_1.Session.basePath, filePath)),
+                content,
+            });
+        }
+        return {
+            script: parsed.entrypoint.content,
+            scriptPath: (0, util_1.pathToPosix)(path.relative(project_1.Session.basePath, parsed.entrypoint.filePath)),
+            dependencies: deps,
+        };
+    }
+    synthesize() {
+        return {
+            ...super.synthesize(),
+            checkType: 'API',
+            request: this.request,
+            localSetupScript: this.localSetupScript,
+            setupScriptPath: this.setupScriptPath,
+            setupScriptDependencies: this.setupScriptDependencies,
+            localTearDownScript: this.localTearDownScript,
+            tearDownScriptPath: this.tearDownScriptPath,
+            tearDownScriptDependencies: this.tearDownScriptDependencies,
+            degradedResponseTime: this.degradedResponseTime,
+            maxResponseTime: this.maxResponseTime,
+        };
+    }
+}
+exports.ApiCheck = ApiCheck;
+//# sourceMappingURL=api-check.js.map