@horietakehiro/aws-cdk-utul 0.41.51 → 0.41.53

package/lib/types/cfn-resource-types/aws-connect-evaluationform.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-connect-evaluationform.js","sourceRoot":"","sources":["aws-connect-evaluationform.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The identifier to reference the item.\n */\nexport type RefId = string\n\n/**\n * Creates an evaluation form for the specified CON instance.\n */\nexport interface _AWS_CONNECT_EVALUATIONFORM {\nScoringStrategy?: ScoringStrategy\n/**\n * The status of the evaluation form.\n *  *Allowed values*: ``DRAFT`` | ``ACTIVE``\n */\nStatus: (\"DRAFT\" | \"ACTIVE\")\nAutoEvaluationConfiguration?: AutoEvaluationConfiguration\n/**\n * The description of the evaluation form.\n *  *Length Constraints*: Minimum length of 0. Maximum length of 1024.\n */\nDescription?: string\n/**\n * The identifier of the Amazon Connect instance.\n */\nInstanceArn: string\n/**\n * A title of the evaluation form.\n */\nTitle: string\n/**\n * Items that are part of the evaluation form. The total number of sections and questions must not exceed 100 each. Questions must be contained in a section.\n *  *Minimum size*: 1\n *  *Maximum size*: 100\n * \n * @minItems 1\n * @maxItems 200\n */\nItems: EvaluationFormBaseItem[]\nEvaluationFormArn?: string\n/**\n * The tags used to organize, track, or control access for this resource. For example, { \"tags\": {\"key1\":\"value1\", \"key2\":\"value2\"} }.\n * \n * @maxItems 50\n */\nTags?: Tag[]\n}\n/**\n * A scoring strategy of the evaluation form.\n */\nexport interface ScoringStrategy {\n/**\n * The scoring status of the evaluation form.\n *  *Allowed values*: ``ENABLED`` | ``DISABLED``\n */\nStatus: (\"ENABLED\" | \"DISABLED\")\n/**\n * The scoring mode of the evaluation form.\n *  *Allowed values*: ``QUESTION_ONLY`` | ``SECTION_ONLY``\n */\nMode: (\"QUESTION_ONLY\" | \"SECTION_ONLY\")\n}\nexport interface AutoEvaluationConfiguration {\nEnabled?: boolean\n}\n/**\n * An item at the root level. All items must be sections.\n */\nexport interface EvaluationFormBaseItem {\nSection: EvaluationFormSection\n}\n/**\n * A subsection or inner section of an item.\n */\nexport interface EvaluationFormSection {\n/**\n * The title of the section.\n *  *Length Constraints*: Minimum length of 1. Maximum length of 128.\n */\nTitle: string\n/**\n * The instructions of the section.\n */\nInstructions?: string\n/**\n * The items of the section.\n *  *Minimum*: 1\n * \n * @minItems 1\n * @maxItems 200\n */\nItems?: EvaluationFormItem[]\n/**\n * The identifier to reference the item.\n */\nRefId: string\n/**\n * The scoring weight of the section.\n *  *Minimum*: 0 \n *  *Maximum*: 100\n */\nWeight?: number\n}\n/**\n * Items that are part of the evaluation form. The total number of sections and questions must not exceed 100 each. Questions must be contained in a section.\n */\nexport interface EvaluationFormItem {\nQuestion?: EvaluationFormQuestion\nSection?: EvaluationFormSection1\n}\n/**\n * The information of the question.\n */\nexport interface EvaluationFormQuestion {\n/**\n * The flag to enable not applicable answers to the question.\n */\nNotApplicableEnabled?: boolean\nEnablement?: EvaluationFormItemEnablementConfiguration\n/**\n * The title of the question.\n *  *Length Constraints*: Minimum length of 1. Maximum length of 350.\n */\nTitle: string\n/**\n * The type of the question.\n *  *Allowed values*: ``NUMERIC`` | ``SINGLESELECT`` | ``TEXT``\n */\nQuestionType: (\"NUMERIC\" | \"SINGLESELECT\" | \"TEXT\" | \"MULTISELECT\" | \"DATETIME\")\n/**\n * The instructions of the section.\n *  *Length Constraints*: Minimum length of 0. Maximum length of 1024.\n */\nInstructions?: string\n/**\n * The identifier to reference the item.\n */\nRefId: string\nQuestionTypeProperties?: EvaluationFormQuestionTypeProperties\n/**\n * The scoring weight of the section.\n *  *Minimum*: 0\n *  *Maximum*: 100\n */\nWeight?: number\n}\nexport interface EvaluationFormItemEnablementConfiguration {\nCondition: EvaluationFormItemEnablementCondition\n/**\n * Defines the enablement status to be applied when the specified condition is met.\n */\nAction: (\"DISABLE\" | \"ENABLE\")\n/**\n * Specifies the default enablement status to be applied when the condition is not satisfied.\n */\nDefaultAction?: (\"DISABLE\" | \"ENABLE\")\n}\n/**\n * Specifies the logical condition that determines when to apply the enablement rules.\n */\nexport interface EvaluationFormItemEnablementCondition {\n/**\n * The logical operator used to combine multiple operands, determining how the condition is evaluated as a whole.\n */\nOperator?: (\"OR\" | \"AND\")\n/**\n * The list of operands that compose the condition. Each operand represents a specific criteria to be evaluated.\n * \n * @minItems 1\n */\nOperands: EvaluationFormItemEnablementConditionOperand[]\n}\nexport interface EvaluationFormItemEnablementConditionOperand {\nExpression?: EvaluationFormItemEnablementExpression\n}\n/**\n * A direct comparison expression that evaluates a form item's value against specified criteria.\n */\nexport interface EvaluationFormItemEnablementExpression {\n/**\n * The list of possible values to compare against the source form item's value.\n * \n * @minItems 1\n */\nValues: EvaluationFormItemEnablementSourceValue[]\nSource: EvaluationFormItemEnablementSource\n/**\n * Specifies the comparison method to determine if the source value matches any of the specified values.\n */\nComparator: (\"IN\" | \"NOT_IN\" | \"ALL_IN\" | \"EXACT\")\n}\nexport interface EvaluationFormItemEnablementSourceValue {\n/**\n * Type of the source entity value.\n */\nType?: \"OPTION_REF_ID\"\n/**\n * The reference id of the source entity value.\n */\nRefId?: string\n}\n/**\n * Identifies the form item whose value will be evaluated in the expression.\n */\nexport interface EvaluationFormItemEnablementSource {\n/**\n * The type of the source entity.\n */\nType: \"QUESTION_REF_ID\"\nRefId?: RefId\n}\n/**\n * The properties of the type of question. Text questions do not have to define question type properties.\n */\nexport interface EvaluationFormQuestionTypeProperties {\nNumeric?: EvaluationFormNumericQuestionProperties\nSingleSelect?: EvaluationFormSingleSelectQuestionProperties\nText?: EvaluationFormTextQuestionProperties\n}\n/**\n * The properties of the numeric question.\n */\nexport interface EvaluationFormNumericQuestionProperties {\n/**\n * The scoring options of the numeric question.\n * \n * @minItems 1\n * @maxItems 10\n */\nOptions?: EvaluationFormNumericQuestionOption[]\nAutomation?: EvaluationFormNumericQuestionAutomation\n/**\n * The minimum answer value.\n */\nMinValue: number\n/**\n * The maximum answer value.\n */\nMaxValue: number\n}\n/**\n * Information about the option range used for scoring in numeric questions.\n */\nexport interface EvaluationFormNumericQuestionOption {\n/**\n * The score assigned to answer values within the range option.\n *  *Minimum*: 0\n *  *Maximum*: 10\n */\nScore?: number\nAutomaticFailConfiguration?: AutomaticFailConfiguration\n/**\n * The minimum answer value of the range option.\n */\nMinValue: number\n/**\n * The maximum answer value of the range option.\n */\nMaxValue: number\n/**\n * The flag to mark the option as automatic fail. If an automatic fail answer is provided, the overall evaluation gets a score of 0.\n */\nAutomaticFail?: boolean\n}\nexport interface AutomaticFailConfiguration {\n/**\n * The target section refId to control failure propagation boundary.\n */\nTargetSection?: string\n}\n/**\n * The automation properties of the numeric question.\n */\nexport interface EvaluationFormNumericQuestionAutomation {\nAnswerSource?: EvaluationFormQuestionAutomationAnswerSource\nPropertyValue?: NumericQuestionPropertyValueAutomation\n}\nexport interface EvaluationFormQuestionAutomationAnswerSource {\n/**\n * The type of the answer source\n */\nSourceType: (\"CONTACT_LENS_DATA\" | \"GEN_AI\")\n}\n/**\n * The property value of the automation.\n */\nexport interface NumericQuestionPropertyValueAutomation {\n/**\n * The property label of the automation.\n */\nLabel: (\"OVERALL_CUSTOMER_SENTIMENT_SCORE\" | \"OVERALL_AGENT_SENTIMENT_SCORE\" | \"NON_TALK_TIME\" | \"NON_TALK_TIME_PERCENTAGE\" | \"NUMBER_OF_INTERRUPTIONS\" | \"CONTACT_DURATION\" | \"AGENT_INTERACTION_DURATION\" | \"CUSTOMER_HOLD_TIME\" | \"LONGEST_HOLD_DURATION\" | \"NUMBER_OF_HOLDS\" | \"AGENT_INTERACTION_AND_HOLD_DURATION\" | \"CUSTOMER_SENTIMENT_SCORE_WITHOUT_AGENT\")\n}\n/**\n * The properties of the numeric question.\n */\nexport interface EvaluationFormSingleSelectQuestionProperties {\n/**\n * The display mode of the single select question.\n *  *Allowed values*: ``DROPDOWN`` | ``RADIO``\n */\nDisplayAs?: (\"DROPDOWN\" | \"RADIO\")\n/**\n * The answer options of the single select question.\n *  *Minimum*: 2\n *  *Maximum*: 256\n * \n * @minItems 2\n * @maxItems 256\n */\nOptions: EvaluationFormSingleSelectQuestionOption[]\nAutomation?: EvaluationFormSingleSelectQuestionAutomation\n}\n/**\n * Information about the automation configuration in single select questions.\n */\nexport interface EvaluationFormSingleSelectQuestionOption {\n/**\n * The score assigned to the answer option.\n *  *Minimum*: 0\n *  *Maximum*: 10\n */\nScore?: number\nAutomaticFailConfiguration?: AutomaticFailConfiguration1\n/**\n * The title of the answer option.\n *  *Length Constraints*: Minimum length of 1. Maximum length of 128.\n */\nText: string\n/**\n * The identifier to reference the item.\n */\nRefId: string\n/**\n * The flag to mark the option as automatic fail. If an automatic fail answer is provided, the overall evaluation gets a score of 0.\n */\nAutomaticFail?: boolean\n}\nexport interface AutomaticFailConfiguration1 {\n/**\n * The target section refId to control failure propagation boundary.\n */\nTargetSection?: string\n}\n/**\n * The display mode of the single select question.\n */\nexport interface EvaluationFormSingleSelectQuestionAutomation {\n/**\n * The automation options of the single select question.\n *  *Minimum*: 1\n *  *Maximum*: 20\n * \n * @minItems 1\n * @maxItems 20\n */\nOptions: EvaluationFormSingleSelectQuestionAutomationOption[]\nAnswerSource?: EvaluationFormQuestionAutomationAnswerSource1\n/**\n * The identifier to reference the item.\n */\nDefaultOptionRefId?: string\n}\n/**\n * The automation options of the single select question.\n */\nexport interface EvaluationFormSingleSelectQuestionAutomationOption {\nRuleCategory: SingleSelectQuestionRuleCategoryAutomation\n}\n/**\n * The automation option based on a rule category for the single select question.\n */\nexport interface SingleSelectQuestionRuleCategoryAutomation {\n/**\n * The condition to apply for the automation option. If the condition is PRESENT, then the option is applied when the contact data includes the category. Similarly, if the condition is NOT_PRESENT, then the option is applied when the contact data does not include the category.\n *  *Allowed values*: ``PRESENT`` | ``NOT_PRESENT``\n *  *Maximum*: 50\n */\nCondition: (\"PRESENT\" | \"NOT_PRESENT\")\n/**\n * The category name, as defined in Rules.\n *  *Minimum*: 1\n *  *Maximum*: 50\n */\nCategory: string\n/**\n * The identifier to reference the item.\n */\nOptionRefId: string\n}\nexport interface EvaluationFormQuestionAutomationAnswerSource1 {\n/**\n * The type of the answer source\n */\nSourceType: (\"CONTACT_LENS_DATA\" | \"GEN_AI\")\n}\nexport interface EvaluationFormTextQuestionProperties {\nAutomation?: EvaluationFormTextQuestionAutomation\n}\n/**\n * Specifies how the question can be automatically answered.\n */\nexport interface EvaluationFormTextQuestionAutomation {\nAnswerSource?: EvaluationFormQuestionAutomationAnswerSource2\n}\n/**\n * The source of automation answer of the question.\n */\nexport interface EvaluationFormQuestionAutomationAnswerSource2 {\n/**\n * The type of the answer source\n */\nSourceType: (\"CONTACT_LENS_DATA\" | \"GEN_AI\")\n}\n/**\n * The information of the section.\n */\nexport interface EvaluationFormSection1 {\n/**\n * The title of the section.\n *  *Length Constraints*: Minimum length of 1. Maximum length of 128.\n */\nTitle: string\n/**\n * The instructions of the section.\n */\nInstructions?: string\n/**\n * The items of the section.\n *  *Minimum*: 1\n * \n * @minItems 1\n * @maxItems 200\n */\nItems?: EvaluationFormItem[]\n/**\n * The identifier to reference the item.\n */\nRefId: string\n/**\n * The scoring weight of the section.\n *  *Minimum*: 0 \n *  *Maximum*: 100\n */\nWeight?: number\n}\n/**\n * A key-value pair to associate with a resource.\n */\nexport interface Tag {\n/**\n * The value for the tag. You can specify a value that is 0 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -\n */\nValue: string\n/**\n * The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -\n */\nKey: string\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-connect-evaluationform.js","sourceRoot":"","sources":["aws-connect-evaluationform.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The identifier to reference the item.\n */\nexport type RefId = string\n/**\n * The option identifiers referencing the options to be selected when the automation option is triggered.\n */\nexport type ReferenceIdList = RefId[]\n/**\n * The option reference identifiers of the default answers.\n */\nexport type ReferenceIdList1 = RefId[]\n\n/**\n * Creates an evaluation form for the specified CON instance.\n */\nexport interface _AWS_CONNECT_EVALUATIONFORM {\n/**\n * A title of the evaluation form.\n */\nTitle: string\n/**\n * The description of the evaluation form.\n *  *Length Constraints*: Minimum length of 0. Maximum length of 1024.\n */\nDescription?: string\nEvaluationFormArn?: string\n/**\n * The identifier of the Amazon Connect instance.\n */\nInstanceArn: string\n/**\n * Items that are part of the evaluation form. The total number of sections and questions must not exceed 100 each. Questions must be contained in a section.\n *  *Minimum size*: 1\n *  *Maximum size*: 100\n * \n * @minItems 1\n * @maxItems 200\n */\nItems: EvaluationFormBaseItem[]\nScoringStrategy?: ScoringStrategy\nAutoEvaluationConfiguration?: AutoEvaluationConfiguration\n/**\n * The status of the evaluation form.\n *  *Allowed values*: ``DRAFT`` | ``ACTIVE``\n */\nStatus: (\"DRAFT\" | \"ACTIVE\")\nTargetConfiguration?: EvaluationFormTargetConfiguration\nLanguageConfiguration?: EvaluationFormLanguageConfiguration\n/**\n * The tags used to organize, track, or control access for this resource. For example, { \"tags\": {\"key1\":\"value1\", \"key2\":\"value2\"} }.\n * \n * @maxItems 50\n */\nTags?: Tag[]\n}\n/**\n * An item at the root level. All items must be sections.\n */\nexport interface EvaluationFormBaseItem {\nSection: EvaluationFormSection\n}\n/**\n * A subsection or inner section of an item.\n */\nexport interface EvaluationFormSection {\n/**\n * The title of the section.\n *  *Length Constraints*: Minimum length of 1. Maximum length of 128.\n */\nTitle: string\n/**\n * The instructions of the section.\n */\nInstructions?: string\n/**\n * The identifier to reference the item.\n */\nRefId: string\n/**\n * The items of the section.\n *  *Minimum*: 1\n * \n * @minItems 1\n * @maxItems 200\n */\nItems?: EvaluationFormItem[]\n/**\n * The scoring weight of the section.\n *  *Minimum*: 0 \n *  *Maximum*: 100\n */\nWeight?: number\n}\n/**\n * Items that are part of the evaluation form. The total number of sections and questions must not exceed 100 each. Questions must be contained in a section.\n */\nexport interface EvaluationFormItem {\nSection?: EvaluationFormSection1\nQuestion?: EvaluationFormQuestion\n}\n/**\n * The information of the section.\n */\nexport interface EvaluationFormSection1 {\n/**\n * The title of the section.\n *  *Length Constraints*: Minimum length of 1. Maximum length of 128.\n */\nTitle: string\n/**\n * The instructions of the section.\n */\nInstructions?: string\n/**\n * The identifier to reference the item.\n */\nRefId: string\n/**\n * The items of the section.\n *  *Minimum*: 1\n * \n * @minItems 1\n * @maxItems 200\n */\nItems?: EvaluationFormItem[]\n/**\n * The scoring weight of the section.\n *  *Minimum*: 0 \n *  *Maximum*: 100\n */\nWeight?: number\n}\n/**\n * The information of the question.\n */\nexport interface EvaluationFormQuestion {\n/**\n * The title of the question.\n *  *Length Constraints*: Minimum length of 1. Maximum length of 350.\n */\nTitle: string\n/**\n * The instructions of the section.\n *  *Length Constraints*: Minimum length of 0. Maximum length of 1024.\n */\nInstructions?: string\n/**\n * The identifier to reference the item.\n */\nRefId: string\n/**\n * The flag to enable not applicable answers to the question.\n */\nNotApplicableEnabled?: boolean\n/**\n * The type of the question.\n *  *Allowed values*: ``NUMERIC`` | ``SINGLESELECT`` | ``TEXT``\n */\nQuestionType: (\"NUMERIC\" | \"SINGLESELECT\" | \"TEXT\" | \"MULTISELECT\" | \"DATETIME\")\nQuestionTypeProperties?: EvaluationFormQuestionTypeProperties\n/**\n * The scoring weight of the section.\n *  *Minimum*: 0\n *  *Maximum*: 100\n */\nWeight?: number\nEnablement?: EvaluationFormItemEnablementConfiguration\n}\n/**\n * The properties of the type of question. Text questions do not have to define question type properties.\n */\nexport interface EvaluationFormQuestionTypeProperties {\nNumeric?: EvaluationFormNumericQuestionProperties\nSingleSelect?: EvaluationFormSingleSelectQuestionProperties\nText?: EvaluationFormTextQuestionProperties\nMultiSelect?: EvaluationFormMultiSelectQuestionProperties\n}\n/**\n * The properties of the numeric question.\n */\nexport interface EvaluationFormNumericQuestionProperties {\n/**\n * The minimum answer value.\n */\nMinValue: number\n/**\n * The maximum answer value.\n */\nMaxValue: number\n/**\n * The scoring options of the numeric question.\n * \n * @minItems 1\n * @maxItems 10\n */\nOptions?: EvaluationFormNumericQuestionOption[]\nAutomation?: EvaluationFormNumericQuestionAutomation\n}\n/**\n * Information about the option range used for scoring in numeric questions.\n */\nexport interface EvaluationFormNumericQuestionOption {\n/**\n * The minimum answer value of the range option.\n */\nMinValue: number\n/**\n * The maximum answer value of the range option.\n */\nMaxValue: number\n/**\n * The score assigned to answer values within the range option.\n *  *Minimum*: 0\n *  *Maximum*: 10\n */\nScore?: number\n/**\n * The flag to mark the option as automatic fail. If an automatic fail answer is provided, the overall evaluation gets a score of 0.\n */\nAutomaticFail?: boolean\nAutomaticFailConfiguration?: AutomaticFailConfiguration\n}\n/**\n * A configuration for automatic fail.\n */\nexport interface AutomaticFailConfiguration {\n/**\n * The referenceId of the target section for auto failure.\n */\nTargetSection?: string\n}\n/**\n * The automation properties of the numeric question.\n */\nexport interface EvaluationFormNumericQuestionAutomation {\nPropertyValue?: NumericQuestionPropertyValueAutomation\nAnswerSource?: EvaluationFormQuestionAutomationAnswerSource\n}\n/**\n * The property value of the automation.\n */\nexport interface NumericQuestionPropertyValueAutomation {\n/**\n * The property label of the automation.\n */\nLabel: (\"OVERALL_CUSTOMER_SENTIMENT_SCORE\" | \"OVERALL_AGENT_SENTIMENT_SCORE\" | \"NON_TALK_TIME\" | \"NON_TALK_TIME_PERCENTAGE\" | \"NUMBER_OF_INTERRUPTIONS\" | \"CONTACT_DURATION\" | \"AGENT_INTERACTION_DURATION\" | \"CUSTOMER_HOLD_TIME\" | \"LONGEST_HOLD_DURATION\" | \"NUMBER_OF_HOLDS\" | \"AGENT_INTERACTION_AND_HOLD_DURATION\" | \"CUSTOMER_SENTIMENT_SCORE_WITHOUT_AGENT\" | \"CUSTOMER_SENTIMENT_SCORE_WITH_AGENT\")\n}\n/**\n * A source of automation answer for numeric question.\n */\nexport interface EvaluationFormQuestionAutomationAnswerSource {\n/**\n * The automation answer source type.\n */\nSourceType: (\"CONTACT_LENS_DATA\" | \"GEN_AI\")\n}\n/**\n * The properties of the numeric question.\n */\nexport interface EvaluationFormSingleSelectQuestionProperties {\n/**\n * The answer options of the single select question.\n *  *Minimum*: 2\n *  *Maximum*: 256\n * \n * @minItems 2\n * @maxItems 256\n */\nOptions: EvaluationFormSingleSelectQuestionOption[]\n/**\n * The display mode of the single select question.\n *  *Allowed values*: ``DROPDOWN`` | ``RADIO``\n */\nDisplayAs?: (\"DROPDOWN\" | \"RADIO\")\nAutomation?: EvaluationFormSingleSelectQuestionAutomation\n}\n/**\n * Information about the automation configuration in single select questions.\n */\nexport interface EvaluationFormSingleSelectQuestionOption {\n/**\n * The identifier to reference the item.\n */\nRefId: string\n/**\n * The title of the answer option.\n *  *Length Constraints*: Minimum length of 1. Maximum length of 128.\n */\nText: string\n/**\n * The score assigned to the answer option.\n *  *Minimum*: 0\n *  *Maximum*: 10\n */\nScore?: number\n/**\n * The flag to mark the option as automatic fail. If an automatic fail answer is provided, the overall evaluation gets a score of 0.\n */\nAutomaticFail?: boolean\nAutomaticFailConfiguration?: AutomaticFailConfiguration1\n}\n/**\n * Whether automatic fail is configured on a single select question.\n */\nexport interface AutomaticFailConfiguration1 {\n/**\n * The referenceId of the target section for auto failure.\n */\nTargetSection?: string\n}\n/**\n * The display mode of the single select question.\n */\nexport interface EvaluationFormSingleSelectQuestionAutomation {\n/**\n * The automation options of the single select question.\n *  *Minimum*: 1\n *  *Maximum*: 20\n * \n * @minItems 1\n * @maxItems 20\n */\nOptions: EvaluationFormSingleSelectQuestionAutomationOption[]\n/**\n * The identifier to reference the item.\n */\nDefaultOptionRefId?: string\nAnswerSource?: EvaluationFormQuestionAutomationAnswerSource1\n}\n/**\n * The automation options of the single select question.\n */\nexport interface EvaluationFormSingleSelectQuestionAutomationOption {\nRuleCategory: SingleSelectQuestionRuleCategoryAutomation\n}\n/**\n * The automation option based on a rule category for the single select question.\n */\nexport interface SingleSelectQuestionRuleCategoryAutomation {\n/**\n * The category name, as defined in Rules.\n *  *Minimum*: 1\n *  *Maximum*: 50\n */\nCategory: string\n/**\n * The condition to apply for the automation option. If the condition is PRESENT, then the option is applied when the contact data includes the category. Similarly, if the condition is NOT_PRESENT, then the option is applied when the contact data does not include the category.\n *  *Allowed values*: ``PRESENT`` | ``NOT_PRESENT``\n *  *Maximum*: 50\n */\nCondition: (\"PRESENT\" | \"NOT_PRESENT\")\n/**\n * The identifier to reference the item.\n */\nOptionRefId: string\n}\n/**\n * Automation answer source.\n */\nexport interface EvaluationFormQuestionAutomationAnswerSource1 {\n/**\n * The automation answer source type.\n */\nSourceType: (\"CONTACT_LENS_DATA\" | \"GEN_AI\")\n}\n/**\n * The properties of the text question.\n */\nexport interface EvaluationFormTextQuestionProperties {\nAutomation?: EvaluationFormTextQuestionAutomation\n}\n/**\n * The automation properties of the text question.\n */\nexport interface EvaluationFormTextQuestionAutomation {\nAnswerSource?: EvaluationFormQuestionAutomationAnswerSource2\n}\n/**\n * Automation answer source.\n */\nexport interface EvaluationFormQuestionAutomationAnswerSource2 {\n/**\n * The automation answer source type.\n */\nSourceType: (\"CONTACT_LENS_DATA\" | \"GEN_AI\")\n}\nexport interface EvaluationFormMultiSelectQuestionProperties {\n/**\n * The list of options for the question.\n * \n * @minItems 2\n * @maxItems 256\n */\nOptions: EvaluationFormMultiSelectQuestionOption[]\n/**\n * The display mode of the multi-select question.\n */\nDisplayAs?: (\"DROPDOWN\" | \"CHECKBOX\")\nAutomation?: EvaluationFormMultiSelectQuestionAutomation\n}\nexport interface EvaluationFormMultiSelectQuestionOption {\n/**\n * The identifier to reference the item.\n */\nRefId: string\n/**\n * The title of the option.\n */\nText: string\n}\n/**\n * The automation properties for the multi-select question.\n */\nexport interface EvaluationFormMultiSelectQuestionAutomation {\n/**\n * The answer options for the automation.\n * \n * @minItems 1\n * @maxItems 20\n */\nOptions: EvaluationFormMultiSelectQuestionAutomationOption[]\nDefaultOptionRefIds?: ReferenceIdList1\nAnswerSource?: EvaluationFormQuestionAutomationAnswerSource3\n}\nexport interface EvaluationFormMultiSelectQuestionAutomationOption {\nRuleCategory: MultiSelectQuestionRuleCategoryAutomation\n}\n/**\n * The automation option based on Rules categories.\n */\nexport interface MultiSelectQuestionRuleCategoryAutomation {\n/**\n * The category name as defined in Rules.\n */\nCategory: string\n/**\n * The automation condition applied on contact categories.\n */\nCondition: (\"PRESENT\" | \"NOT_PRESENT\")\nOptionRefIds: ReferenceIdList\n}\n/**\n * The source of automation answer of the question.\n */\nexport interface EvaluationFormQuestionAutomationAnswerSource3 {\n/**\n * The automation answer source type.\n */\nSourceType: (\"CONTACT_LENS_DATA\" | \"GEN_AI\")\n}\n/**\n * A question conditional enablement.\n */\nexport interface EvaluationFormItemEnablementConfiguration {\nCondition: EvaluationFormItemEnablementCondition\n/**\n * An enablement action that if condition is satisfied.\n */\nAction: (\"DISABLE\" | \"ENABLE\")\n/**\n * An enablement action that if condition is not satisfied.\n */\nDefaultAction?: (\"DISABLE\" | \"ENABLE\")\n}\n/**\n * A condition for item enablement configuration.\n */\nexport interface EvaluationFormItemEnablementCondition {\n/**\n * Operands of the enablement condition.\n * \n * @minItems 1\n */\nOperands: EvaluationFormItemEnablementConditionOperand[]\n/**\n * The operator to be used to be applied to operands if more than one provided.\n */\nOperator?: (\"OR\" | \"AND\")\n}\n/**\n * An operand of the enablement condition.\n */\nexport interface EvaluationFormItemEnablementConditionOperand {\nExpression?: EvaluationFormItemEnablementExpression\n}\n/**\n * An expression of the enablement condition.\n */\nexport interface EvaluationFormItemEnablementExpression {\nSource: EvaluationFormItemEnablementSource\n/**\n * A list of values from source item.\n * \n * @minItems 1\n */\nValues: EvaluationFormItemEnablementSourceValue[]\n/**\n * A comparator to be used against list of values.\n */\nComparator: (\"IN\" | \"NOT_IN\" | \"ALL_IN\" | \"EXACT\")\n}\n/**\n * A source item of enablement expression.\n */\nexport interface EvaluationFormItemEnablementSource {\n/**\n * A type of source item.\n */\nType: \"QUESTION_REF_ID\"\n/**\n * The identifier to reference the item.\n */\nRefId?: string\n}\n/**\n * An enablement expression source value.\n */\nexport interface EvaluationFormItemEnablementSourceValue {\n/**\n * A type of source item value.\n */\nType?: \"OPTION_REF_ID\"\n/**\n * The identifier to reference the item.\n */\nRefId?: string\n}\n/**\n * A scoring strategy of the evaluation form.\n */\nexport interface ScoringStrategy {\n/**\n * The scoring mode of the evaluation form.\n *  *Allowed values*: ``QUESTION_ONLY`` | ``SECTION_ONLY``\n */\nMode: (\"QUESTION_ONLY\" | \"SECTION_ONLY\")\n/**\n * The scoring status of the evaluation form.\n *  *Allowed values*: ``ENABLED`` | ``DISABLED``\n */\nStatus: (\"ENABLED\" | \"DISABLED\")\n}\n/**\n * The automatic evaluation configuration of an evaluation form.\n */\nexport interface AutoEvaluationConfiguration {\nEnabled?: boolean\n}\nexport interface EvaluationFormTargetConfiguration {\n/**\n * The interaction type of a contact\n */\nContactInteractionType: (\"AGENT\" | \"AUTOMATED\")\n}\nexport interface EvaluationFormLanguageConfiguration {\n/**\n * The language of the form\n */\nFormLanguage?: (\"de-DE\" | \"en-US\" | \"es-ES\" | \"fr-FR\" | \"it-IT\" | \"pt-BR\")\n}\n/**\n * A key-value pair to associate with a resource.\n */\nexport interface Tag {\n/**\n * The key name of the tag. You can specify a value that is 1 to 128 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -\n */\nKey: string\n/**\n * The value for the tag. You can specify a value that is 0 to 256 Unicode characters in length and cannot be prefixed with aws:. You can use any of the following characters: the set of Unicode letters, digits, whitespace, _, ., /, =, +, and -\n */\nValue: string\n}\n"]}

package/lib/types/cfn-resource-types/aws-devopsagent-agentspace.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Resource Type definition for AWS::DevOpsAgent::AgentSpace
+ */
+export interface _AWS_DEVOPSAGENT_AGENTSPACE {
+    /**
+     * The unique identifier of the AgentSpace
+     */
+    AgentSpaceId?: string;
+    /**
+     * The name of the AgentSpace.
+     */
+    Name: string;
+    /**
+     * The description of the AgentSpace.
+     */
+    Description?: string;
+    /**
+     * The timestamp when the resource was created.
+     */
+    CreatedAt?: string;
+    /**
+     * The timestamp when the resource was last updated.
+     */
+    UpdatedAt?: string;
+    /**
+     * The Amazon Resource Name (ARN) of the AgentSpace.
+     */
+    Arn?: string;
+}

package/lib/types/cfn-resource-types/aws-devopsagent-agentspace.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXdzLWRldm9wc2FnZW50LWFnZW50c3BhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJhd3MtZGV2b3BzYWdlbnQtYWdlbnRzcGFjZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBSZXNvdXJjZSBUeXBlIGRlZmluaXRpb24gZm9yIEFXUzo6RGV2T3BzQWdlbnQ6OkFnZW50U3BhY2VcbiAqL1xuZXhwb3J0IGludGVyZmFjZSBfQVdTX0RFVk9QU0FHRU5UX0FHRU5UU1BBQ0Uge1xuLyoqXG4gKiBUaGUgdW5pcXVlIGlkZW50aWZpZXIgb2YgdGhlIEFnZW50U3BhY2VcbiAqL1xuQWdlbnRTcGFjZUlkPzogc3RyaW5nXG4vKipcbiAqIFRoZSBuYW1lIG9mIHRoZSBBZ2VudFNwYWNlLlxuICovXG5OYW1lOiBzdHJpbmdcbi8qKlxuICogVGhlIGRlc2NyaXB0aW9uIG9mIHRoZSBBZ2VudFNwYWNlLlxuICovXG5EZXNjcmlwdGlvbj86IHN0cmluZ1xuLyoqXG4gKiBUaGUgdGltZXN0YW1wIHdoZW4gdGhlIHJlc291cmNlIHdhcyBjcmVhdGVkLlxuICovXG5DcmVhdGVkQXQ/OiBzdHJpbmdcbi8qKlxuICogVGhlIHRpbWVzdGFtcCB3aGVuIHRoZSByZXNvdXJjZSB3YXMgbGFzdCB1cGRhdGVkLlxuICovXG5VcGRhdGVkQXQ/OiBzdHJpbmdcbi8qKlxuICogVGhlIEFtYXpvbiBSZXNvdXJjZSBOYW1lIChBUk4pIG9mIHRoZSBBZ2VudFNwYWNlLlxuICovXG5Bcm4/OiBzdHJpbmdcbn1cbiJdfQ==

package/lib/types/cfn-resource-types/aws-devopsagent-association.d.ts

@@ -0,0 +1,320 @@
+/**
+ * The configuration that directs how AgentSpace interacts with the given service
+ */
+export type ServiceConfiguration = ({
+    SourceAws: SourceAwsConfiguration;
+} | {
+    Aws: AWSConfiguration;
+} | {
+    GitHub: GitHubConfiguration;
+} | {
+    Slack: SlackConfiguration;
+} | {
+    Dynatrace: DynatraceConfiguration;
+} | {
+    ServiceNow: ServiceNowConfiguration;
+} | {
+    MCPServer: MCPServerConfiguration;
+} | {
+    GitLab: GitLabConfiguration;
+} | {
+    MCPServerDatadog: MCPServerDatadogConfiguration;
+} | {
+    MCPServerSplunk: MCPServerSplunkConfiguration;
+} | {
+    MCPServerNewRelic: MCPServerNewRelicConfiguration;
+} | {
+    EventChannel: EventChannelConfiguration;
+});
+/**
+ * List of AWS resources
+ */
+export type AWSResourceList = AWSResource[];
+/**
+ * List of AWS tags as key-value pairs
+ */
+export type AWSTagList = KeyValuePair[];
+/**
+ * Resource Type definition for AWS::DevOpsAgent::Association defining how the AgentSpace interacts with external services like GitHub, Slack, AWS accounts, and others.
+ */
+export interface _AWS_DEVOPSAGENT_ASSOCIATION {
+    /**
+     * The unique identifier of the AgentSpace
+     */
+    AgentSpaceId: string;
+    /**
+     * The unique identifier of the association
+     */
+    AssociationId?: string;
+    /**
+     * The identifier for the associated service
+     */
+    ServiceId: string;
+    Configuration: ServiceConfiguration;
+    /**
+     * The timestamp when the association was created
+     */
+    CreatedAt?: string;
+    /**
+     * The timestamp when the association was last updated
+     */
+    UpdatedAt?: string;
+}
+/**
+ * AWS association for 'source' account
+ */
+export interface SourceAwsConfiguration {
+    /**
+     * AWS Account Id corresponding to provided resources
+     */
+    AccountId: string;
+    /**
+     * Account Type 'source' for DevOpsAgent monitoring
+     */
+    AccountType: "source";
+    /**
+     * Role ARN to be assumed by DevOpsAgent to operate on behalf of customer
+     */
+    AssumableRoleArn: string;
+    Resources?: AWSResourceList;
+    Tags?: AWSTagList;
+}
+/**
+ * AWS resource definition
+ */
+export interface AWSResource {
+    /**
+     * Resource type
+     */
+    ResourceType?: ("AWS::CloudFormation::Stack" | "AWS::ECR::Repository" | "AWS::S3::Bucket" | "AWS::S3::Object");
+    /**
+     * The Amazon Resource Name (ARN) of the resource
+     */
+    ResourceArn: string;
+    /**
+     * Additional metadata for the resource
+     */
+    ResourceMetadata?: {
+        [k: string]: unknown;
+    };
+}
+/**
+ * A key-value pair for tags
+ */
+export interface KeyValuePair {
+    Key: string;
+    Value: string;
+}
+/**
+ * AWS association for 'monitor' account
+ */
+export interface AWSConfiguration {
+    /**
+     * AWS Account Id corresponding to provided resources
+     */
+    AccountId: string;
+    /**
+     * Account Type 'monitor' for DevOpsAgent monitoring
+     */
+    AccountType: "monitor";
+    /**
+     * Role ARN to be assumed by DevOpsAgent to operate on behalf of customer
+     */
+    AssumableRoleArn: string;
+    Resources?: AWSResourceList;
+    Tags?: AWSTagList;
+}
+/**
+ * GitHub repository integration configuration
+ */
+export interface GitHubConfiguration {
+    /**
+     * Associated Github repo name
+     */
+    RepoName: string;
+    /**
+     * Associated Github repo ID
+     */
+    RepoId: string;
+    /**
+     * Repository owner
+     */
+    Owner: string;
+    /**
+     * Type of repository owner
+     */
+    OwnerType: ("organization" | "user");
+}
+/**
+ * Slack workspace integration configuration
+ */
+export interface SlackConfiguration {
+    /**
+     * Associated Slack workspace ID
+     */
+    WorkspaceId: string;
+    /**
+     * Associated Slack workspace name
+     */
+    WorkspaceName: string;
+    TransmissionTarget: SlackTransmissionTarget;
+}
+/**
+ * Transmission targets for agent notifications
+ */
+export interface SlackTransmissionTarget {
+    IncidentResponseTarget: SlackChannel;
+}
+/**
+ * Destination for IncidentResponse agent.
+ */
+export interface SlackChannel {
+    /**
+     * Slack channel name
+     */
+    ChannelName?: string;
+    /**
+     * Slack channel ID
+     */
+    ChannelId: string;
+}
+/**
+ * Dynatrace monitoring configuration
+ */
+export interface DynatraceConfiguration {
+    /**
+     * Dynatrace environment id
+     */
+    EnvId: string;
+    /**
+     * List of Dynatrace resources to monitor
+     */
+    Resources?: string[];
+    /**
+     * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service
+     */
+    EnableWebhookUpdates?: boolean;
+}
+/**
+ * ServiceNow integration configuration
+ */
+export interface ServiceNowConfiguration {
+    /**
+     * ServiceNow instance ID
+     */
+    InstanceId?: string;
+    /**
+     * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service
+     */
+    EnableWebhookUpdates?: boolean;
+}
+/**
+ * MCP server configuration
+ */
+export interface MCPServerConfiguration {
+    /**
+     * The name of the MCP server
+     */
+    Name: string;
+    /**
+     * MCP server endpoint URL
+     */
+    Endpoint: string;
+    /**
+     * List of MCP tools that can be used with the association
+     */
+    Tools: string[];
+    /**
+     * The description of the MCP server
+     */
+    Description?: string;
+    /**
+     * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service
+     */
+    EnableWebhookUpdates?: boolean;
+}
+/**
+ * GitLab project integration configuration
+ */
+export interface GitLabConfiguration {
+    /**
+     * GitLab numeric project ID
+     */
+    ProjectId: string;
+    /**
+     * Full GitLab project path (e.g., namespace/project-name)
+     */
+    ProjectPath: string;
+    /**
+     * GitLab instance identifier
+     */
+    InstanceIdentifier?: string;
+    /**
+     * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service
+     */
+    EnableWebhookUpdates?: boolean;
+}
+/**
+ * Datadog MCP server configuration
+ */
+export interface MCPServerDatadogConfiguration {
+    /**
+     * The name of the MCP server
+     */
+    Name: string;
+    /**
+     * MCP server endpoint URL
+     */
+    Endpoint: string;
+    /**
+     * The description of the MCP server
+     */
+    Description?: string;
+    /**
+     * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service
+     */
+    EnableWebhookUpdates?: boolean;
+}
+/**
+ * Splunk MCP server configuration
+ */
+export interface MCPServerSplunkConfiguration {
+    /**
+     * The name of the MCP server
+     */
+    Name: string;
+    /**
+     * MCP server endpoint URL
+     */
+    Endpoint: string;
+    /**
+     * The description of the MCP server
+     */
+    Description?: string;
+    /**
+     * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service
+     */
+    EnableWebhookUpdates?: boolean;
+}
+/**
+ * NewRelic MCP server configuration
+ */
+export interface MCPServerNewRelicConfiguration {
+    /**
+     * New Relic Account ID
+     */
+    AccountId: string;
+    /**
+     * MCP server endpoint URL (e.g., https://mcp.newrelic.com/mcp/)
+     */
+    Endpoint: string;
+}
+/**
+ * EventChannelconfiguration
+ */
+export interface EventChannelConfiguration {
+    /**
+     * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service
+     */
+    EnableWebhookUpdates?: boolean;
+}

package/lib/types/cfn-resource-types/aws-devopsagent-association.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"aws-devopsagent-association.js","sourceRoot":"","sources":["aws-devopsagent-association.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * The configuration that directs how AgentSpace interacts with the given service\n */\nexport type ServiceConfiguration = ({\nSourceAws: SourceAwsConfiguration\n} | {\nAws: AWSConfiguration\n} | {\nGitHub: GitHubConfiguration\n} | {\nSlack: SlackConfiguration\n} | {\nDynatrace: DynatraceConfiguration\n} | {\nServiceNow: ServiceNowConfiguration\n} | {\nMCPServer: MCPServerConfiguration\n} | {\nGitLab: GitLabConfiguration\n} | {\nMCPServerDatadog: MCPServerDatadogConfiguration\n} | {\nMCPServerSplunk: MCPServerSplunkConfiguration\n} | {\nMCPServerNewRelic: MCPServerNewRelicConfiguration\n} | {\nEventChannel: EventChannelConfiguration\n})\n/**\n * List of AWS resources\n */\nexport type AWSResourceList = AWSResource[]\n/**\n * List of AWS tags as key-value pairs\n */\nexport type AWSTagList = KeyValuePair[]\n\n/**\n * Resource Type definition for AWS::DevOpsAgent::Association defining how the AgentSpace interacts with external services like GitHub, Slack, AWS accounts, and others.\n */\nexport interface _AWS_DEVOPSAGENT_ASSOCIATION {\n/**\n * The unique identifier of the AgentSpace\n */\nAgentSpaceId: string\n/**\n * The unique identifier of the association\n */\nAssociationId?: string\n/**\n * The identifier for the associated service\n */\nServiceId: string\nConfiguration: ServiceConfiguration\n/**\n * The timestamp when the association was created\n */\nCreatedAt?: string\n/**\n * The timestamp when the association was last updated\n */\nUpdatedAt?: string\n}\n/**\n * AWS association for 'source' account\n */\nexport interface SourceAwsConfiguration {\n/**\n * AWS Account Id corresponding to provided resources\n */\nAccountId: string\n/**\n * Account Type 'source' for DevOpsAgent monitoring\n */\nAccountType: \"source\"\n/**\n * Role ARN to be assumed by DevOpsAgent to operate on behalf of customer\n */\nAssumableRoleArn: string\nResources?: AWSResourceList\nTags?: AWSTagList\n}\n/**\n * AWS resource definition\n */\nexport interface AWSResource {\n/**\n * Resource type\n */\nResourceType?: (\"AWS::CloudFormation::Stack\" | \"AWS::ECR::Repository\" | \"AWS::S3::Bucket\" | \"AWS::S3::Object\")\n/**\n * The Amazon Resource Name (ARN) of the resource\n */\nResourceArn: string\n/**\n * Additional metadata for the resource\n */\nResourceMetadata?: {\n[k: string]: unknown\n}\n}\n/**\n * A key-value pair for tags\n */\nexport interface KeyValuePair {\nKey: string\nValue: string\n}\n/**\n * AWS association for 'monitor' account\n */\nexport interface AWSConfiguration {\n/**\n * AWS Account Id corresponding to provided resources\n */\nAccountId: string\n/**\n * Account Type 'monitor' for DevOpsAgent monitoring\n */\nAccountType: \"monitor\"\n/**\n * Role ARN to be assumed by DevOpsAgent to operate on behalf of customer\n */\nAssumableRoleArn: string\nResources?: AWSResourceList\nTags?: AWSTagList\n}\n/**\n * GitHub repository integration configuration\n */\nexport interface GitHubConfiguration {\n/**\n * Associated Github repo name\n */\nRepoName: string\n/**\n * Associated Github repo ID\n */\nRepoId: string\n/**\n * Repository owner\n */\nOwner: string\n/**\n * Type of repository owner\n */\nOwnerType: (\"organization\" | \"user\")\n}\n/**\n * Slack workspace integration configuration\n */\nexport interface SlackConfiguration {\n/**\n * Associated Slack workspace ID\n */\nWorkspaceId: string\n/**\n * Associated Slack workspace name\n */\nWorkspaceName: string\nTransmissionTarget: SlackTransmissionTarget\n}\n/**\n * Transmission targets for agent notifications\n */\nexport interface SlackTransmissionTarget {\nIncidentResponseTarget: SlackChannel\n}\n/**\n * Destination for IncidentResponse agent.\n */\nexport interface SlackChannel {\n/**\n * Slack channel name\n */\nChannelName?: string\n/**\n * Slack channel ID\n */\nChannelId: string\n}\n/**\n * Dynatrace monitoring configuration\n */\nexport interface DynatraceConfiguration {\n/**\n * Dynatrace environment id\n */\nEnvId: string\n/**\n * List of Dynatrace resources to monitor\n */\nResources?: string[]\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * ServiceNow integration configuration\n */\nexport interface ServiceNowConfiguration {\n/**\n * ServiceNow instance ID\n */\nInstanceId?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * MCP server configuration\n */\nexport interface MCPServerConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * List of MCP tools that can be used with the association\n */\nTools: string[]\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * GitLab project integration configuration\n */\nexport interface GitLabConfiguration {\n/**\n * GitLab numeric project ID\n */\nProjectId: string\n/**\n * Full GitLab project path (e.g., namespace/project-name)\n */\nProjectPath: string\n/**\n * GitLab instance identifier\n */\nInstanceIdentifier?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * Datadog MCP server configuration\n */\nexport interface MCPServerDatadogConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * Splunk MCP server configuration\n */\nexport interface MCPServerSplunkConfiguration {\n/**\n * The name of the MCP server\n */\nName: string\n/**\n * MCP server endpoint URL\n */\nEndpoint: string\n/**\n * The description of the MCP server\n */\nDescription?: string\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n/**\n * NewRelic MCP server configuration\n */\nexport interface MCPServerNewRelicConfiguration {\n/**\n * New Relic Account ID\n */\nAccountId: string\n/**\n * MCP server endpoint URL (e.g., https://mcp.newrelic.com/mcp/)\n */\nEndpoint: string\n}\n/**\n * EventChannelconfiguration\n */\nexport interface EventChannelConfiguration {\n/**\n * When set to true, enables the Agent Space to create and update webhooks for receiving notifications and events from the service\n */\nEnableWebhookUpdates?: boolean\n}\n"]}

package/lib/types/cfn-resource-types/aws-lambda-capacityprovider.d.ts

@@ -0,0 +1,135 @@
+/**
+ * The scaling mode for the capacity provider.
+ */
+export type CapacityProviderScalingMode = ("Auto" | "Manual");
+/**
+ * The predefined metric for target tracking.
+ */
+export type CapacityProviderPredefinedMetricType = "LambdaCapacityProviderAverageCPUUtilization";
+/**
+ * Specifications for the types of EC2 instances that the capacity provider can use.
+ */
+export type Architecture = ("x86_64" | "arm64");
+/**
+ * Resource Type definition for AWS::Lambda::CapacityProvider
+ */
+export interface _AWS_LAMBDA_CAPACITYPROVIDER {
+    /**
+     * The Amazon Resource Name (ARN) of the capacity provider. This is a read-only property that is automatically generated when the capacity provider is created.
+     */
+    Arn?: string;
+    /**
+     * The name of the capacity provider. The name must be unique within your AWS account and region. If you don't specify a name, CloudFormation generates one.
+     */
+    CapacityProviderName?: string;
+    CapacityProviderScalingConfig?: CapacityProviderScalingConfig;
+    InstanceRequirements?: InstanceRequirements;
+    /**
+     * The ARN of the AWS Key Management Service (KMS) key used by the capacity provider.
+     */
+    KmsKeyArn?: string;
+    PermissionsConfig: CapacityProviderPermissionsConfig;
+    /**
+     * The current state of the capacity provider.
+     */
+    State?: ("Pending" | "Active" | "Failed" | "Deleting");
+    /**
+     * A list of tags to apply to the capacity provider.
+     */
+    Tags?: Tag[];
+    VpcConfig: CapacityProviderVpcConfig;
+}
+/**
+ * The scaling configuration for the capacity provider.
+ */
+export interface CapacityProviderScalingConfig {
+    /**
+     * The maximum number of EC2 instances that the capacity provider can scale up to.
+     */
+    MaxVCpuCount?: number;
+    ScalingMode?: CapacityProviderScalingMode;
+    /**
+     * A list of target tracking scaling policies for the capacity provider.
+     *
+     * @minItems 1
+     * @maxItems 10
+     */
+    ScalingPolicies?: TargetTrackingScalingPolicy[];
+}
+/**
+ * A target tracking scaling policy for the capacity provider.
+ */
+export interface TargetTrackingScalingPolicy {
+    PredefinedMetricType: CapacityProviderPredefinedMetricType;
+    /**
+     * The target value for the metric as a percentage (for example, 70.0 for 70%).
+     */
+    TargetValue: number;
+}
+/**
+ * Specifications for the types of EC2 instances that the capacity provider can use.
+ */
+export interface InstanceRequirements {
+    /**
+     * The instruction set architecture for EC2 instances. Specify either x86_64 or arm64.
+     *
+     * @minItems 1
+     * @maxItems 1
+     */
+    Architectures?: Architecture[];
+    /**
+     * A list of instance types that the capacity provider can use. Supports wildcards (for example, m5.*).
+     *
+     * @minItems 0
+     * @maxItems 400
+     */
+    AllowedInstanceTypes?: string[];
+    /**
+     * A list of instance types that the capacity provider should not use. Takes precedence over AllowedInstanceTypes.
+     *
+     * @minItems 0
+     * @maxItems 400
+     */
+    ExcludedInstanceTypes?: string[];
+}
+/**
+ * IAM permissions configuration for the capacity provider.
+ */
+export interface CapacityProviderPermissionsConfig {
+    /**
+     * The ARN of the IAM role that Lambda assumes to manage the capacity provider.
+     */
+    CapacityProviderOperatorRoleArn: string;
+}
+/**
+ * A key-value pair that provides metadata for the capacity provider.
+ */
+export interface Tag {
+    /**
+     * The key name of the tag.
+     */
+    Key: string;
+    /**
+     * The value for the tag.
+     */
+    Value?: string;
+}
+/**
+ * VPC configuration for the capacity provider.
+ */
+export interface CapacityProviderVpcConfig {
+    /**
+     * A list of subnet IDs where the capacity provider can launch EC2 instances.
+     *
+     * @minItems 1
+     * @maxItems 16
+     */
+    SubnetIds: string[];
+    /**
+     * A list of security group IDs to associate with EC2 instances.
+     *
+     * @minItems 0
+     * @maxItems 5
+     */
+    SecurityGroupIds: string[];
+}

package/lib/types/cfn-resource-types/aws-lambda-capacityprovider.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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