@cdktf-providers/newrelic 3.75.4

package/dist/application-settings/index.js

@@ -0,0 +1,966 @@
+// https://registry.terraform.io/providers/newrelic/newrelic/3.75.4/docs/resources/application_settings
+// generated from terraform resource schema
+import * as cdktf from 'cdktf';
+export function applicationSettingsErrorCollectorToTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    return {
+        expected_error_classes: cdktf.listMapper(cdktf.stringToTerraform, false)(struct.expectedErrorClasses),
+        expected_error_codes: cdktf.listMapper(cdktf.stringToTerraform, false)(struct.expectedErrorCodes),
+        ignored_error_classes: cdktf.listMapper(cdktf.stringToTerraform, false)(struct.ignoredErrorClasses),
+        ignored_error_codes: cdktf.listMapper(cdktf.stringToTerraform, false)(struct.ignoredErrorCodes),
+    };
+}
+export function applicationSettingsErrorCollectorToHclTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    const attrs = {
+        expected_error_classes: {
+            value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(struct.expectedErrorClasses),
+            isBlock: false,
+            type: "list",
+            storageClassType: "stringList",
+        },
+        expected_error_codes: {
+            value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(struct.expectedErrorCodes),
+            isBlock: false,
+            type: "list",
+            storageClassType: "stringList",
+        },
+        ignored_error_classes: {
+            value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(struct.ignoredErrorClasses),
+            isBlock: false,
+            type: "list",
+            storageClassType: "stringList",
+        },
+        ignored_error_codes: {
+            value: cdktf.listMapperHcl(cdktf.stringToHclTerraform, false)(struct.ignoredErrorCodes),
+            isBlock: false,
+            type: "list",
+            storageClassType: "stringList",
+        },
+    };
+    // remove undefined attributes
+    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+}
+export class ApplicationSettingsErrorCollectorOutputReference extends cdktf.ComplexObject {
+    isEmptyObject = false;
+    resolvableValue;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param complexObjectIndex the index of this item in the list
+    * @param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource, terraformAttribute, complexObjectIndex, complexObjectIsFromSet) {
+        super(terraformResource, terraformAttribute, complexObjectIsFromSet, complexObjectIndex);
+    }
+    get internalValue() {
+        if (this.resolvableValue) {
+            return this.resolvableValue;
+        }
+        let hasAnyValues = this.isEmptyObject;
+        const internalValueResult = {};
+        if (this._expectedErrorClasses !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.expectedErrorClasses = this._expectedErrorClasses;
+        }
+        if (this._expectedErrorCodes !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.expectedErrorCodes = this._expectedErrorCodes;
+        }
+        if (this._ignoredErrorClasses !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.ignoredErrorClasses = this._ignoredErrorClasses;
+        }
+        if (this._ignoredErrorCodes !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.ignoredErrorCodes = this._ignoredErrorCodes;
+        }
+        return hasAnyValues ? internalValueResult : undefined;
+    }
+    set internalValue(value) {
+        if (value === undefined) {
+            this.isEmptyObject = false;
+            this.resolvableValue = undefined;
+            this._expectedErrorClasses = undefined;
+            this._expectedErrorCodes = undefined;
+            this._ignoredErrorClasses = undefined;
+            this._ignoredErrorCodes = undefined;
+        }
+        else if (cdktf.Tokenization.isResolvable(value)) {
+            this.isEmptyObject = false;
+            this.resolvableValue = value;
+        }
+        else {
+            this.isEmptyObject = Object.keys(value).length === 0;
+            this.resolvableValue = undefined;
+            this._expectedErrorClasses = value.expectedErrorClasses;
+            this._expectedErrorCodes = value.expectedErrorCodes;
+            this._ignoredErrorClasses = value.ignoredErrorClasses;
+            this._ignoredErrorCodes = value.ignoredErrorCodes;
+        }
+    }
+    // expected_error_classes - computed: false, optional: true, required: false
+    _expectedErrorClasses;
+    get expectedErrorClasses() {
+        return this.getListAttribute('expected_error_classes');
+    }
+    set expectedErrorClasses(value) {
+        this._expectedErrorClasses = value;
+    }
+    resetExpectedErrorClasses() {
+        this._expectedErrorClasses = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get expectedErrorClassesInput() {
+        return this._expectedErrorClasses;
+    }
+    // expected_error_codes - computed: false, optional: true, required: false
+    _expectedErrorCodes;
+    get expectedErrorCodes() {
+        return this.getListAttribute('expected_error_codes');
+    }
+    set expectedErrorCodes(value) {
+        this._expectedErrorCodes = value;
+    }
+    resetExpectedErrorCodes() {
+        this._expectedErrorCodes = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get expectedErrorCodesInput() {
+        return this._expectedErrorCodes;
+    }
+    // ignored_error_classes - computed: false, optional: true, required: false
+    _ignoredErrorClasses;
+    get ignoredErrorClasses() {
+        return this.getListAttribute('ignored_error_classes');
+    }
+    set ignoredErrorClasses(value) {
+        this._ignoredErrorClasses = value;
+    }
+    resetIgnoredErrorClasses() {
+        this._ignoredErrorClasses = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get ignoredErrorClassesInput() {
+        return this._ignoredErrorClasses;
+    }
+    // ignored_error_codes - computed: false, optional: true, required: false
+    _ignoredErrorCodes;
+    get ignoredErrorCodes() {
+        return this.getListAttribute('ignored_error_codes');
+    }
+    set ignoredErrorCodes(value) {
+        this._ignoredErrorCodes = value;
+    }
+    resetIgnoredErrorCodes() {
+        this._ignoredErrorCodes = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get ignoredErrorCodesInput() {
+        return this._ignoredErrorCodes;
+    }
+}
+export class ApplicationSettingsErrorCollectorList extends cdktf.ComplexList {
+    terraformResource;
+    terraformAttribute;
+    wrapsSet;
+    internalValue;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource, terraformAttribute, wrapsSet) {
+        super(terraformResource, terraformAttribute, wrapsSet);
+        this.terraformResource = terraformResource;
+        this.terraformAttribute = terraformAttribute;
+        this.wrapsSet = wrapsSet;
+    }
+    /**
+    * @param index the index of the item to return
+    */
+    get(index) {
+        return new ApplicationSettingsErrorCollectorOutputReference(this.terraformResource, this.terraformAttribute, index, this.wrapsSet);
+    }
+}
+export function applicationSettingsTransactionTracerExplainQueryPlansToTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    return {
+        query_plan_threshold_type: cdktf.stringToTerraform(struct.queryPlanThresholdType),
+        query_plan_threshold_value: cdktf.numberToTerraform(struct.queryPlanThresholdValue),
+    };
+}
+export function applicationSettingsTransactionTracerExplainQueryPlansToHclTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    const attrs = {
+        query_plan_threshold_type: {
+            value: cdktf.stringToHclTerraform(struct.queryPlanThresholdType),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "string",
+        },
+        query_plan_threshold_value: {
+            value: cdktf.numberToHclTerraform(struct.queryPlanThresholdValue),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "number",
+        },
+    };
+    // remove undefined attributes
+    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+}
+export class ApplicationSettingsTransactionTracerExplainQueryPlansOutputReference extends cdktf.ComplexObject {
+    isEmptyObject = false;
+    resolvableValue;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param complexObjectIndex the index of this item in the list
+    * @param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource, terraformAttribute, complexObjectIndex, complexObjectIsFromSet) {
+        super(terraformResource, terraformAttribute, complexObjectIsFromSet, complexObjectIndex);
+    }
+    get internalValue() {
+        if (this.resolvableValue) {
+            return this.resolvableValue;
+        }
+        let hasAnyValues = this.isEmptyObject;
+        const internalValueResult = {};
+        if (this._queryPlanThresholdType !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.queryPlanThresholdType = this._queryPlanThresholdType;
+        }
+        if (this._queryPlanThresholdValue !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.queryPlanThresholdValue = this._queryPlanThresholdValue;
+        }
+        return hasAnyValues ? internalValueResult : undefined;
+    }
+    set internalValue(value) {
+        if (value === undefined) {
+            this.isEmptyObject = false;
+            this.resolvableValue = undefined;
+            this._queryPlanThresholdType = undefined;
+            this._queryPlanThresholdValue = undefined;
+        }
+        else if (cdktf.Tokenization.isResolvable(value)) {
+            this.isEmptyObject = false;
+            this.resolvableValue = value;
+        }
+        else {
+            this.isEmptyObject = Object.keys(value).length === 0;
+            this.resolvableValue = undefined;
+            this._queryPlanThresholdType = value.queryPlanThresholdType;
+            this._queryPlanThresholdValue = value.queryPlanThresholdValue;
+        }
+    }
+    // query_plan_threshold_type - computed: false, optional: true, required: false
+    _queryPlanThresholdType;
+    get queryPlanThresholdType() {
+        return this.getStringAttribute('query_plan_threshold_type');
+    }
+    set queryPlanThresholdType(value) {
+        this._queryPlanThresholdType = value;
+    }
+    resetQueryPlanThresholdType() {
+        this._queryPlanThresholdType = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get queryPlanThresholdTypeInput() {
+        return this._queryPlanThresholdType;
+    }
+    // query_plan_threshold_value - computed: false, optional: true, required: false
+    _queryPlanThresholdValue;
+    get queryPlanThresholdValue() {
+        return this.getNumberAttribute('query_plan_threshold_value');
+    }
+    set queryPlanThresholdValue(value) {
+        this._queryPlanThresholdValue = value;
+    }
+    resetQueryPlanThresholdValue() {
+        this._queryPlanThresholdValue = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get queryPlanThresholdValueInput() {
+        return this._queryPlanThresholdValue;
+    }
+}
+export class ApplicationSettingsTransactionTracerExplainQueryPlansList extends cdktf.ComplexList {
+    terraformResource;
+    terraformAttribute;
+    wrapsSet;
+    internalValue;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource, terraformAttribute, wrapsSet) {
+        super(terraformResource, terraformAttribute, wrapsSet);
+        this.terraformResource = terraformResource;
+        this.terraformAttribute = terraformAttribute;
+        this.wrapsSet = wrapsSet;
+    }
+    /**
+    * @param index the index of the item to return
+    */
+    get(index) {
+        return new ApplicationSettingsTransactionTracerExplainQueryPlansOutputReference(this.terraformResource, this.terraformAttribute, index, this.wrapsSet);
+    }
+}
+export function applicationSettingsTransactionTracerSqlToTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    return {
+        record_sql: cdktf.stringToTerraform(struct.recordSql),
+    };
+}
+export function applicationSettingsTransactionTracerSqlToHclTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    const attrs = {
+        record_sql: {
+            value: cdktf.stringToHclTerraform(struct.recordSql),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "string",
+        },
+    };
+    // remove undefined attributes
+    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+}
+export class ApplicationSettingsTransactionTracerSqlOutputReference extends cdktf.ComplexObject {
+    isEmptyObject = false;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    */
+    constructor(terraformResource, terraformAttribute) {
+        super(terraformResource, terraformAttribute, false, 0);
+    }
+    get internalValue() {
+        let hasAnyValues = this.isEmptyObject;
+        const internalValueResult = {};
+        if (this._recordSql !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.recordSql = this._recordSql;
+        }
+        return hasAnyValues ? internalValueResult : undefined;
+    }
+    set internalValue(value) {
+        if (value === undefined) {
+            this.isEmptyObject = false;
+            this._recordSql = undefined;
+        }
+        else {
+            this.isEmptyObject = Object.keys(value).length === 0;
+            this._recordSql = value.recordSql;
+        }
+    }
+    // record_sql - computed: false, optional: false, required: true
+    _recordSql;
+    get recordSql() {
+        return this.getStringAttribute('record_sql');
+    }
+    set recordSql(value) {
+        this._recordSql = value;
+    }
+    // Temporarily expose input value. Use with caution.
+    get recordSqlInput() {
+        return this._recordSql;
+    }
+}
+export function applicationSettingsTransactionTracerToTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    return {
+        stack_trace_threshold_value: cdktf.numberToTerraform(struct.stackTraceThresholdValue),
+        transaction_threshold_type: cdktf.stringToTerraform(struct.transactionThresholdType),
+        transaction_threshold_value: cdktf.numberToTerraform(struct.transactionThresholdValue),
+        explain_query_plans: cdktf.listMapper(applicationSettingsTransactionTracerExplainQueryPlansToTerraform, true)(struct.explainQueryPlans),
+        sql: applicationSettingsTransactionTracerSqlToTerraform(struct.sql),
+    };
+}
+export function applicationSettingsTransactionTracerToHclTerraform(struct) {
+    if (!cdktf.canInspect(struct) || cdktf.Tokenization.isResolvable(struct)) {
+        return struct;
+    }
+    if (cdktf.isComplexElement(struct)) {
+        throw new Error("A complex element was used as configuration, this is not supported: https://cdk.tf/complex-object-as-configuration");
+    }
+    const attrs = {
+        stack_trace_threshold_value: {
+            value: cdktf.numberToHclTerraform(struct.stackTraceThresholdValue),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "number",
+        },
+        transaction_threshold_type: {
+            value: cdktf.stringToHclTerraform(struct.transactionThresholdType),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "string",
+        },
+        transaction_threshold_value: {
+            value: cdktf.numberToHclTerraform(struct.transactionThresholdValue),
+            isBlock: false,
+            type: "simple",
+            storageClassType: "number",
+        },
+        explain_query_plans: {
+            value: cdktf.listMapperHcl(applicationSettingsTransactionTracerExplainQueryPlansToHclTerraform, true)(struct.explainQueryPlans),
+            isBlock: true,
+            type: "list",
+            storageClassType: "ApplicationSettingsTransactionTracerExplainQueryPlansList",
+        },
+        sql: {
+            value: applicationSettingsTransactionTracerSqlToHclTerraform(struct.sql),
+            isBlock: true,
+            type: "list",
+            storageClassType: "ApplicationSettingsTransactionTracerSqlList",
+        },
+    };
+    // remove undefined attributes
+    return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+}
+export class ApplicationSettingsTransactionTracerOutputReference extends cdktf.ComplexObject {
+    isEmptyObject = false;
+    resolvableValue;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param complexObjectIndex the index of this item in the list
+    * @param complexObjectIsFromSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource, terraformAttribute, complexObjectIndex, complexObjectIsFromSet) {
+        super(terraformResource, terraformAttribute, complexObjectIsFromSet, complexObjectIndex);
+    }
+    get internalValue() {
+        if (this.resolvableValue) {
+            return this.resolvableValue;
+        }
+        let hasAnyValues = this.isEmptyObject;
+        const internalValueResult = {};
+        if (this._stackTraceThresholdValue !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.stackTraceThresholdValue = this._stackTraceThresholdValue;
+        }
+        if (this._transactionThresholdType !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.transactionThresholdType = this._transactionThresholdType;
+        }
+        if (this._transactionThresholdValue !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.transactionThresholdValue = this._transactionThresholdValue;
+        }
+        if (this._explainQueryPlans?.internalValue !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.explainQueryPlans = this._explainQueryPlans?.internalValue;
+        }
+        if (this._sql?.internalValue !== undefined) {
+            hasAnyValues = true;
+            internalValueResult.sql = this._sql?.internalValue;
+        }
+        return hasAnyValues ? internalValueResult : undefined;
+    }
+    set internalValue(value) {
+        if (value === undefined) {
+            this.isEmptyObject = false;
+            this.resolvableValue = undefined;
+            this._stackTraceThresholdValue = undefined;
+            this._transactionThresholdType = undefined;
+            this._transactionThresholdValue = undefined;
+            this._explainQueryPlans.internalValue = undefined;
+            this._sql.internalValue = undefined;
+        }
+        else if (cdktf.Tokenization.isResolvable(value)) {
+            this.isEmptyObject = false;
+            this.resolvableValue = value;
+        }
+        else {
+            this.isEmptyObject = Object.keys(value).length === 0;
+            this.resolvableValue = undefined;
+            this._stackTraceThresholdValue = value.stackTraceThresholdValue;
+            this._transactionThresholdType = value.transactionThresholdType;
+            this._transactionThresholdValue = value.transactionThresholdValue;
+            this._explainQueryPlans.internalValue = value.explainQueryPlans;
+            this._sql.internalValue = value.sql;
+        }
+    }
+    // stack_trace_threshold_value - computed: false, optional: true, required: false
+    _stackTraceThresholdValue;
+    get stackTraceThresholdValue() {
+        return this.getNumberAttribute('stack_trace_threshold_value');
+    }
+    set stackTraceThresholdValue(value) {
+        this._stackTraceThresholdValue = value;
+    }
+    resetStackTraceThresholdValue() {
+        this._stackTraceThresholdValue = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get stackTraceThresholdValueInput() {
+        return this._stackTraceThresholdValue;
+    }
+    // transaction_threshold_type - computed: false, optional: true, required: false
+    _transactionThresholdType;
+    get transactionThresholdType() {
+        return this.getStringAttribute('transaction_threshold_type');
+    }
+    set transactionThresholdType(value) {
+        this._transactionThresholdType = value;
+    }
+    resetTransactionThresholdType() {
+        this._transactionThresholdType = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get transactionThresholdTypeInput() {
+        return this._transactionThresholdType;
+    }
+    // transaction_threshold_value - computed: false, optional: true, required: false
+    _transactionThresholdValue;
+    get transactionThresholdValue() {
+        return this.getNumberAttribute('transaction_threshold_value');
+    }
+    set transactionThresholdValue(value) {
+        this._transactionThresholdValue = value;
+    }
+    resetTransactionThresholdValue() {
+        this._transactionThresholdValue = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get transactionThresholdValueInput() {
+        return this._transactionThresholdValue;
+    }
+    // explain_query_plans - computed: false, optional: true, required: false
+    _explainQueryPlans = new ApplicationSettingsTransactionTracerExplainQueryPlansList(this, "explain_query_plans", false);
+    get explainQueryPlans() {
+        return this._explainQueryPlans;
+    }
+    putExplainQueryPlans(value) {
+        this._explainQueryPlans.internalValue = value;
+    }
+    resetExplainQueryPlans() {
+        this._explainQueryPlans.internalValue = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get explainQueryPlansInput() {
+        return this._explainQueryPlans.internalValue;
+    }
+    // sql - computed: false, optional: true, required: false
+    _sql = new ApplicationSettingsTransactionTracerSqlOutputReference(this, "sql");
+    get sql() {
+        return this._sql;
+    }
+    putSql(value) {
+        this._sql.internalValue = value;
+    }
+    resetSql() {
+        this._sql.internalValue = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get sqlInput() {
+        return this._sql.internalValue;
+    }
+}
+export class ApplicationSettingsTransactionTracerList extends cdktf.ComplexList {
+    terraformResource;
+    terraformAttribute;
+    wrapsSet;
+    internalValue;
+    /**
+    * @param terraformResource The parent resource
+    * @param terraformAttribute The attribute on the parent resource this class is referencing
+    * @param wrapsSet whether the list is wrapping a set (will add tolist() to be able to access an item via an index)
+    */
+    constructor(terraformResource, terraformAttribute, wrapsSet) {
+        super(terraformResource, terraformAttribute, wrapsSet);
+        this.terraformResource = terraformResource;
+        this.terraformAttribute = terraformAttribute;
+        this.wrapsSet = wrapsSet;
+    }
+    /**
+    * @param index the index of the item to return
+    */
+    get(index) {
+        return new ApplicationSettingsTransactionTracerOutputReference(this.terraformResource, this.terraformAttribute, index, this.wrapsSet);
+    }
+}
+/**
+* Represents a {@link https://registry.terraform.io/providers/newrelic/newrelic/3.75.4/docs/resources/application_settings newrelic_application_settings}
+*/
+export class ApplicationSettings extends cdktf.TerraformResource {
+    // =================
+    // STATIC PROPERTIES
+    // =================
+    static tfResourceType = "newrelic_application_settings";
+    // ==============
+    // STATIC Methods
+    // ==============
+    /**
+    * Generates CDKTF code for importing a ApplicationSettings resource upon running "cdktf plan <stack-name>"
+    * @param scope The scope in which to define this construct
+    * @param importToId The construct id used in the generated config for the ApplicationSettings to import
+    * @param importFromId The id of the existing ApplicationSettings that should be imported. Refer to the {@link https://registry.terraform.io/providers/newrelic/newrelic/3.75.4/docs/resources/application_settings#import import section} in the documentation of this resource for the id to use
+    * @param provider? Optional instance of the provider where the ApplicationSettings to import is found
+    */
+    static generateConfigForImport(scope, importToId, importFromId, provider) {
+        return new cdktf.ImportableResource(scope, importToId, { terraformResourceType: "newrelic_application_settings", importId: importFromId, provider });
+    }
+    // ===========
+    // INITIALIZER
+    // ===========
+    /**
+    * Create a new {@link https://registry.terraform.io/providers/newrelic/newrelic/3.75.4/docs/resources/application_settings newrelic_application_settings} Resource
+    *
+    * @param scope The scope in which to define this construct
+    * @param id The scoped construct ID. Must be unique amongst siblings in the same scope
+    * @param options ApplicationSettingsConfig = {}
+    */
+    constructor(scope, id, config = {}) {
+        super(scope, id, {
+            terraformResourceType: 'newrelic_application_settings',
+            terraformGeneratorMetadata: {
+                providerName: 'newrelic',
+                providerVersion: '3.75.4',
+                providerVersionConstraint: '3.75.4'
+            },
+            provider: config.provider,
+            dependsOn: config.dependsOn,
+            count: config.count,
+            lifecycle: config.lifecycle,
+            provisioners: config.provisioners,
+            connection: config.connection,
+            forEach: config.forEach
+        });
+        this._appApdexThreshold = config.appApdexThreshold;
+        this._enableRealUserMonitoring = config.enableRealUserMonitoring;
+        this._enableSlowSql = config.enableSlowSql;
+        this._enableThreadProfiler = config.enableThreadProfiler;
+        this._endUserApdexThreshold = config.endUserApdexThreshold;
+        this._guid = config.guid;
+        this._id = config.id;
+        this._name = config.name;
+        this._tracerType = config.tracerType;
+        this._useServerSideConfig = config.useServerSideConfig;
+        this._errorCollector.internalValue = config.errorCollector;
+        this._transactionTracer.internalValue = config.transactionTracer;
+    }
+    // ==========
+    // ATTRIBUTES
+    // ==========
+    // app_apdex_threshold - computed: false, optional: true, required: false
+    _appApdexThreshold;
+    get appApdexThreshold() {
+        return this.getNumberAttribute('app_apdex_threshold');
+    }
+    set appApdexThreshold(value) {
+        this._appApdexThreshold = value;
+    }
+    resetAppApdexThreshold() {
+        this._appApdexThreshold = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get appApdexThresholdInput() {
+        return this._appApdexThreshold;
+    }
+    // enable_real_user_monitoring - computed: false, optional: true, required: false
+    _enableRealUserMonitoring;
+    get enableRealUserMonitoring() {
+        return this.getBooleanAttribute('enable_real_user_monitoring');
+    }
+    set enableRealUserMonitoring(value) {
+        this._enableRealUserMonitoring = value;
+    }
+    resetEnableRealUserMonitoring() {
+        this._enableRealUserMonitoring = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get enableRealUserMonitoringInput() {
+        return this._enableRealUserMonitoring;
+    }
+    // enable_slow_sql - computed: false, optional: true, required: false
+    _enableSlowSql;
+    get enableSlowSql() {
+        return this.getBooleanAttribute('enable_slow_sql');
+    }
+    set enableSlowSql(value) {
+        this._enableSlowSql = value;
+    }
+    resetEnableSlowSql() {
+        this._enableSlowSql = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get enableSlowSqlInput() {
+        return this._enableSlowSql;
+    }
+    // enable_thread_profiler - computed: false, optional: true, required: false
+    _enableThreadProfiler;
+    get enableThreadProfiler() {
+        return this.getBooleanAttribute('enable_thread_profiler');
+    }
+    set enableThreadProfiler(value) {
+        this._enableThreadProfiler = value;
+    }
+    resetEnableThreadProfiler() {
+        this._enableThreadProfiler = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get enableThreadProfilerInput() {
+        return this._enableThreadProfiler;
+    }
+    // end_user_apdex_threshold - computed: false, optional: true, required: false
+    _endUserApdexThreshold;
+    get endUserApdexThreshold() {
+        return this.getNumberAttribute('end_user_apdex_threshold');
+    }
+    set endUserApdexThreshold(value) {
+        this._endUserApdexThreshold = value;
+    }
+    resetEndUserApdexThreshold() {
+        this._endUserApdexThreshold = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get endUserApdexThresholdInput() {
+        return this._endUserApdexThreshold;
+    }
+    // guid - computed: true, optional: true, required: false
+    _guid;
+    get guid() {
+        return this.getStringAttribute('guid');
+    }
+    set guid(value) {
+        this._guid = value;
+    }
+    resetGuid() {
+        this._guid = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get guidInput() {
+        return this._guid;
+    }
+    // id - computed: true, optional: true, required: false
+    _id;
+    get id() {
+        return this.getStringAttribute('id');
+    }
+    set id(value) {
+        this._id = value;
+    }
+    resetId() {
+        this._id = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get idInput() {
+        return this._id;
+    }
+    // is_imported - computed: true, optional: false, required: false
+    get isImported() {
+        return this.getBooleanAttribute('is_imported');
+    }
+    // name - computed: true, optional: true, required: false
+    _name;
+    get name() {
+        return this.getStringAttribute('name');
+    }
+    set name(value) {
+        this._name = value;
+    }
+    resetName() {
+        this._name = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get nameInput() {
+        return this._name;
+    }
+    // tracer_type - computed: false, optional: true, required: false
+    _tracerType;
+    get tracerType() {
+        return this.getStringAttribute('tracer_type');
+    }
+    set tracerType(value) {
+        this._tracerType = value;
+    }
+    resetTracerType() {
+        this._tracerType = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get tracerTypeInput() {
+        return this._tracerType;
+    }
+    // use_server_side_config - computed: false, optional: true, required: false
+    _useServerSideConfig;
+    get useServerSideConfig() {
+        return this.getBooleanAttribute('use_server_side_config');
+    }
+    set useServerSideConfig(value) {
+        this._useServerSideConfig = value;
+    }
+    resetUseServerSideConfig() {
+        this._useServerSideConfig = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get useServerSideConfigInput() {
+        return this._useServerSideConfig;
+    }
+    // error_collector - computed: false, optional: true, required: false
+    _errorCollector = new ApplicationSettingsErrorCollectorList(this, "error_collector", false);
+    get errorCollector() {
+        return this._errorCollector;
+    }
+    putErrorCollector(value) {
+        this._errorCollector.internalValue = value;
+    }
+    resetErrorCollector() {
+        this._errorCollector.internalValue = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get errorCollectorInput() {
+        return this._errorCollector.internalValue;
+    }
+    // transaction_tracer - computed: false, optional: true, required: false
+    _transactionTracer = new ApplicationSettingsTransactionTracerList(this, "transaction_tracer", false);
+    get transactionTracer() {
+        return this._transactionTracer;
+    }
+    putTransactionTracer(value) {
+        this._transactionTracer.internalValue = value;
+    }
+    resetTransactionTracer() {
+        this._transactionTracer.internalValue = undefined;
+    }
+    // Temporarily expose input value. Use with caution.
+    get transactionTracerInput() {
+        return this._transactionTracer.internalValue;
+    }
+    // =========
+    // SYNTHESIS
+    // =========
+    synthesizeAttributes() {
+        return {
+            app_apdex_threshold: cdktf.numberToTerraform(this._appApdexThreshold),
+            enable_real_user_monitoring: cdktf.booleanToTerraform(this._enableRealUserMonitoring),
+            enable_slow_sql: cdktf.booleanToTerraform(this._enableSlowSql),
+            enable_thread_profiler: cdktf.booleanToTerraform(this._enableThreadProfiler),
+            end_user_apdex_threshold: cdktf.numberToTerraform(this._endUserApdexThreshold),
+            guid: cdktf.stringToTerraform(this._guid),
+            id: cdktf.stringToTerraform(this._id),
+            name: cdktf.stringToTerraform(this._name),
+            tracer_type: cdktf.stringToTerraform(this._tracerType),
+            use_server_side_config: cdktf.booleanToTerraform(this._useServerSideConfig),
+            error_collector: cdktf.listMapper(applicationSettingsErrorCollectorToTerraform, true)(this._errorCollector.internalValue),
+            transaction_tracer: cdktf.listMapper(applicationSettingsTransactionTracerToTerraform, true)(this._transactionTracer.internalValue),
+        };
+    }
+    synthesizeHclAttributes() {
+        const attrs = {
+            app_apdex_threshold: {
+                value: cdktf.numberToHclTerraform(this._appApdexThreshold),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "number",
+            },
+            enable_real_user_monitoring: {
+                value: cdktf.booleanToHclTerraform(this._enableRealUserMonitoring),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            enable_slow_sql: {
+                value: cdktf.booleanToHclTerraform(this._enableSlowSql),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            enable_thread_profiler: {
+                value: cdktf.booleanToHclTerraform(this._enableThreadProfiler),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            end_user_apdex_threshold: {
+                value: cdktf.numberToHclTerraform(this._endUserApdexThreshold),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "number",
+            },
+            guid: {
+                value: cdktf.stringToHclTerraform(this._guid),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            id: {
+                value: cdktf.stringToHclTerraform(this._id),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            name: {
+                value: cdktf.stringToHclTerraform(this._name),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            tracer_type: {
+                value: cdktf.stringToHclTerraform(this._tracerType),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "string",
+            },
+            use_server_side_config: {
+                value: cdktf.booleanToHclTerraform(this._useServerSideConfig),
+                isBlock: false,
+                type: "simple",
+                storageClassType: "boolean",
+            },
+            error_collector: {
+                value: cdktf.listMapperHcl(applicationSettingsErrorCollectorToHclTerraform, true)(this._errorCollector.internalValue),
+                isBlock: true,
+                type: "list",
+                storageClassType: "ApplicationSettingsErrorCollectorList",
+            },
+            transaction_tracer: {
+                value: cdktf.listMapperHcl(applicationSettingsTransactionTracerToHclTerraform, true)(this._transactionTracer.internalValue),
+                isBlock: true,
+                type: "list",
+                storageClassType: "ApplicationSettingsTransactionTracerList",
+            },
+        };
+        // remove undefined attributes
+        return Object.fromEntries(Object.entries(attrs).filter(([_, value]) => value !== undefined && value.value !== undefined));
+    }
+}