@robhan-cdk-lib/aws_grafana 0.0.65 → 0.0.66

package/lib/validation/workspace-base.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Validates the clientToken property.
+ *
+ * @param token - The client token to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Must be between 1 and 64 characters long
+ * - Must contain only printable ASCII characters
+ */
+export declare function validateClientToken(token: unknown): string[];
+/**
+ * Validates the description property.
+ *
+ * @param description - The description to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Maximum length of 2048 characters
+ */
+export declare function validateDescription(description: unknown): string[];
+/**
+ * Validates the grafanaVersion property.
+ *
+ * @param version - The Grafana version to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Must be between 1 and 255 characters long
+ */
+export declare function validateGrafanaVersion(version: unknown): string[];
+/**
+ * Validates the name property.
+ *
+ * @param name - The workspace name to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Must be between 1 and 255 characters long
+ * - Can only contain alphanumeric characters, hyphens, dots, underscores, and tildes
+ */
+export declare function validateName(name: unknown): string[];
+/**
+ * Validates the networkAccessControl property.
+ *
+ * @param nac - The network access control configuration to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - prefixLists (if present) must be an array with at most 5 items
+ * - vpcEndpoints (if present) must be an array with at most 5 items
+ */
+export declare function validateNetworkAccessControl(nac: unknown): string[];
+/**
+ * Validates the organizationRoleName property.
+ *
+ * @param roleName - The organization role name to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Must be between 1 and 2048 characters long
+ */
+export declare function validateOrganizationRoleName(roleName: unknown): string[];
+/**
+ * Validates the SAML assertion attributes.
+ *
+ * @param obj - The SAML assertion attributes to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - Each attribute must be a string
+ * - Each attribute must be between 1 and 256 characters long
+ * - Valid attribute keys are: 'email', 'groups', 'login', 'name', 'org', 'role'
+ */
+export declare function validateSamlAssertionAttributes(obj: unknown): string[];
+/**
+ * Validates the SAML IdP metadata.
+ *
+ * @param obj - The SAML IdP metadata to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - url (if present) must be a string between 1 and 2048 characters long
+ * - xml (if present) must be a string
+ */
+export declare function validateSamlIdpMetadata(obj: unknown): string[];
+/**
+ * Validates the SAML configuration.
+ *
+ * @param config - The SAML configuration to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - idpMetadata is required and must be valid
+ * - assertionAtrributes (if present) must be valid
+ * - allowedOrganizations (if present) must be an array of strings with 1-256 elements
+ * - loginValidityDuration (if present) must be a positive number
+ * - roleValues (if present) must be an object with valid admin and editor arrays
+ */
+export declare function validateSamlConfiguration(config: unknown): string[];
+/**
+ * Validates the vpcConfiguration property.
+ *
+ * @param config - The VPC configuration to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - securityGroups is required and must be an array with 1-5 items
+ * - subnets is required and must be an array with 2-6 items
+ */
+export declare function validateVpcConfiguration(config: unknown): string[];

package/lib/validation/workspace-base.js

@@ -0,0 +1,427 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateClientToken = validateClientToken;
+exports.validateDescription = validateDescription;
+exports.validateGrafanaVersion = validateGrafanaVersion;
+exports.validateName = validateName;
+exports.validateNetworkAccessControl = validateNetworkAccessControl;
+exports.validateOrganizationRoleName = validateOrganizationRoleName;
+exports.validateSamlAssertionAttributes = validateSamlAssertionAttributes;
+exports.validateSamlIdpMetadata = validateSamlIdpMetadata;
+exports.validateSamlConfiguration = validateSamlConfiguration;
+exports.validateVpcConfiguration = validateVpcConfiguration;
+const utils_1 = require("@robhan-cdk-lib/utils");
+/**
+ * Validates the clientToken property.
+ *
+ * @param token - The client token to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Must be between 1 and 64 characters long
+ * - Must contain only printable ASCII characters
+ */
+function validateClientToken(token) {
+    const errors = [];
+    if (typeof token !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: token,
+        min: 1,
+        max: 64,
+    }));
+    errors.push(...(0, utils_1.validateRegExp)({
+        value: token,
+        regExp: /^[!-~]*$/,
+        message: 'must contain only printable ASCII characters',
+    }));
+    return errors;
+}
+/**
+ * Validates the description property.
+ *
+ * @param description - The description to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Maximum length of 2048 characters
+ */
+function validateDescription(description) {
+    const errors = [];
+    if (typeof description !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: description,
+        max: 2048,
+    }));
+    return errors;
+}
+/**
+ * Validates the grafanaVersion property.
+ *
+ * @param version - The Grafana version to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Must be between 1 and 255 characters long
+ */
+function validateGrafanaVersion(version) {
+    const errors = [];
+    if (typeof version !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: version,
+        min: 1,
+        max: 255,
+    }));
+    return errors;
+}
+/**
+ * Validates the name property.
+ *
+ * @param name - The workspace name to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Must be between 1 and 255 characters long
+ * - Can only contain alphanumeric characters, hyphens, dots, underscores, and tildes
+ */
+function validateName(name) {
+    const errors = [];
+    if (typeof name !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateRegExp)({
+        value: name,
+        regExp: /^[a-zA-Z0-9\-._~]+$/,
+        message: 'can only contain alphanumeric characters, hyphens, dots, underscores, and tildes',
+    }));
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: name,
+        min: 1,
+        max: 255,
+    }));
+    return errors;
+}
+/**
+ * Validates the networkAccessControl property.
+ *
+ * @param nac - The network access control configuration to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - prefixLists (if present) must be an array with at most 5 items
+ * - vpcEndpoints (if present) must be an array with at most 5 items
+ */
+function validateNetworkAccessControl(nac) {
+    const errors = [];
+    if (!nac || typeof nac !== 'object') {
+        errors.push('must be an object');
+        return errors;
+    }
+    const networkAccessControl = nac;
+    // Check prefixLists if present
+    if (networkAccessControl.prefixLists !== undefined) {
+        if (!Array.isArray(networkAccessControl.prefixLists)) {
+            errors.push('prefixLists must be an array');
+        }
+        else {
+            errors.push(...(0, utils_1.validateArrayLength)({
+                value: networkAccessControl.prefixLists,
+                max: 5,
+                messagePrefix: 'prefixLists ',
+            }));
+        }
+    }
+    // Check vpcEndpoints if present
+    if (networkAccessControl.vpcEndpoints !== undefined) {
+        if (!Array.isArray(networkAccessControl.vpcEndpoints)) {
+            errors.push('vpcEndpoints must be an array');
+        }
+        else {
+            errors.push(...(0, utils_1.validateArrayLength)({
+                value: networkAccessControl.vpcEndpoints,
+                max: 5,
+                messagePrefix: 'vpcEndpoints ',
+            }));
+        }
+    }
+    return errors;
+}
+/**
+ * Validates the organizationRoleName property.
+ *
+ * @param roleName - The organization role name to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be a string
+ * - Must be between 1 and 2048 characters long
+ */
+function validateOrganizationRoleName(roleName) {
+    const errors = [];
+    if (typeof roleName !== 'string') {
+        errors.push('must be a string');
+        return errors; // No need to check further if not a string
+    }
+    errors.push(...(0, utils_1.validateStringLength)({
+        value: roleName,
+        min: 1,
+        max: 2048,
+    }));
+    return errors;
+}
+/**
+ * Validates the SAML assertion attributes.
+ *
+ * @param obj - The SAML assertion attributes to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - Each attribute must be a string
+ * - Each attribute must be between 1 and 256 characters long
+ * - Valid attribute keys are: 'email', 'groups', 'login', 'name', 'org', 'role'
+ */
+function validateSamlAssertionAttributes(obj) {
+    const errors = [];
+    if (!obj || typeof obj !== 'object') {
+        return ['must be an object'];
+    }
+    const attributes = obj;
+    for (const key in attributes) {
+        const value = attributes[key];
+        if (value === undefined) {
+            continue; // Optional properties can be undefined
+        }
+        if (typeof value !== 'string') {
+            errors.push(`Property '${key}' must be a string`);
+        }
+        else {
+            errors.push(...(0, utils_1.validateStringLength)({
+                value,
+                min: 1,
+                max: 256,
+                messagePrefix: `Property '${key}' `,
+            }));
+        }
+    }
+    return errors;
+}
+/**
+ * Validates the SAML IdP metadata.
+ *
+ * @param obj - The SAML IdP metadata to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - url (if present) must be a string between 1 and 2048 characters long
+ * - xml (if present) must be a string
+ */
+function validateSamlIdpMetadata(obj) {
+    const errors = [];
+    if (!obj || typeof obj !== 'object') {
+        return ['must be an object'];
+    }
+    const metadata = obj;
+    // Check url property if present
+    if (metadata.url !== undefined) {
+        if (typeof metadata.url !== 'string') {
+            errors.push("Property 'url' must be a string");
+        }
+        else {
+            errors.push(...(0, utils_1.validateStringLength)({
+                value: metadata.url,
+                min: 1,
+                max: 2048,
+                messagePrefix: "Property 'url' ",
+            }));
+        }
+    }
+    // Check xml property if present
+    if (metadata.xml !== undefined && typeof metadata.xml !== 'string') {
+        errors.push("Property 'xml' must be a string");
+    }
+    return errors;
+}
+/**
+ * Validates the SAML configuration.
+ *
+ * @param config - The SAML configuration to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - idpMetadata is required and must be valid
+ * - assertionAtrributes (if present) must be valid
+ * - allowedOrganizations (if present) must be an array of strings with 1-256 elements
+ * - loginValidityDuration (if present) must be a positive number
+ * - roleValues (if present) must be an object with valid admin and editor arrays
+ */
+function validateSamlConfiguration(config) {
+    const errors = [];
+    if (!config || typeof config !== 'object') {
+        errors.push('must be an object');
+        return errors;
+    }
+    const samlConfig = config;
+    // Check idpMetadata (required)
+    if (samlConfig.idpMetadata === undefined) {
+        errors.push('idpMetadata is required in samlConfiguration');
+    }
+    else {
+        const idpMetadataErrors = validateSamlIdpMetadata(samlConfig.idpMetadata);
+        if (idpMetadataErrors.length > 0) {
+            errors.push(...idpMetadataErrors.map((err) => `idpMetadata: ${err}`));
+        }
+    }
+    // Check assertionAtrributes if present
+    if (samlConfig.assertionAtrributes !== undefined) {
+        const attributeErrors = validateSamlAssertionAttributes(samlConfig.assertionAtrributes);
+        if (attributeErrors.length > 0) {
+            errors.push(...attributeErrors.map((err) => `assertionAtrributes: ${err}`));
+        }
+    }
+    // Check allowedOrganizations if present
+    if (samlConfig.allowedOrganizations !== undefined) {
+        if (!Array.isArray(samlConfig.allowedOrganizations)) {
+            errors.push('allowedOrganizations must be an array');
+        }
+        else {
+            errors.push(...(0, utils_1.validateArrayLength)({
+                value: samlConfig.allowedOrganizations,
+                min: 1,
+                max: 256,
+                messagePrefix: 'allowedOrganizations ',
+            }));
+            for (let i = 0; i < samlConfig.allowedOrganizations.length; i++) {
+                const org = samlConfig.allowedOrganizations[i];
+                if (typeof org !== 'string') {
+                    errors.push(`allowedOrganizations[${i}] must be a string`);
+                }
+            }
+        }
+    }
+    // Check loginValidityDuration if present
+    if (samlConfig.loginValidityDuration !== undefined) {
+        if (typeof samlConfig.loginValidityDuration !== 'number') {
+            errors.push('loginValidityDuration must be a number');
+        }
+        else {
+            errors.push(...(0, utils_1.validateNumberRange)({
+                value: samlConfig.loginValidityDuration,
+                min: 1,
+                messagePrefix: 'loginValidityDuration ',
+            }));
+        }
+    }
+    // Check roleValues if present
+    if (samlConfig.roleValues !== undefined) {
+        if (!samlConfig.roleValues || typeof samlConfig.roleValues !== 'object') {
+            errors.push('roleValues must be an object');
+        }
+        else {
+            // Check admin array if present
+            if (samlConfig.roleValues.admin !== undefined) {
+                if (!Array.isArray(samlConfig.roleValues.admin)) {
+                    errors.push('roleValues.admin must be an array');
+                }
+                else {
+                    for (let i = 0; i < samlConfig.roleValues.admin.length; i++) {
+                        if (typeof samlConfig.roleValues.admin[i] !== 'string') {
+                            errors.push(`roleValues.admin[${i}] must be a string`);
+                        }
+                    }
+                    errors.push(...(0, utils_1.validateArrayLength)({
+                        value: samlConfig.roleValues.admin,
+                        max: 256,
+                        messagePrefix: 'roleValues.admin ',
+                    }));
+                }
+            }
+            // Check editor array if present
+            if (samlConfig.roleValues.editor !== undefined) {
+                if (!Array.isArray(samlConfig.roleValues.editor)) {
+                    errors.push('roleValues.editor must be an array');
+                }
+                else {
+                    for (let i = 0; i < samlConfig.roleValues.editor.length; i++) {
+                        if (typeof samlConfig.roleValues.editor[i] !== 'string') {
+                            errors.push(`roleValues.editor[${i}] must be a string`);
+                        }
+                    }
+                    errors.push(...(0, utils_1.validateArrayLength)({
+                        value: samlConfig.roleValues.editor,
+                        max: 256,
+                        messagePrefix: 'roleValues.editor ',
+                    }));
+                }
+            }
+        }
+    }
+    return errors;
+}
+/**
+ * Validates the vpcConfiguration property.
+ *
+ * @param config - The VPC configuration to validate
+ * @returns An array of error messages if validation fails, or an empty array if valid
+ *
+ * Validation rules:
+ * - Must be an object
+ * - securityGroups is required and must be an array with 1-5 items
+ * - subnets is required and must be an array with 2-6 items
+ */
+function validateVpcConfiguration(config) {
+    const errors = [];
+    if (!config || typeof config !== 'object') {
+        errors.push('vpcConfiguration must be an object');
+        return errors;
+    }
+    const vpcConfig = config;
+    // Check securityGroups (required)
+    if (vpcConfig.securityGroups === undefined) {
+        errors.push('securityGroups is required in vpcConfiguration');
+    }
+    else if (!Array.isArray(vpcConfig.securityGroups)) {
+        errors.push('securityGroups must be an array');
+    }
+    else {
+        errors.push(...(0, utils_1.validateArrayLength)({
+            value: vpcConfig.securityGroups,
+            min: 1,
+            max: 5,
+            messagePrefix: 'securityGroups ',
+        }));
+    }
+    // Check subnets (required)
+    if (vpcConfig.subnets === undefined) {
+        errors.push('subnets is required in vpcConfiguration');
+    }
+    else if (!Array.isArray(vpcConfig.subnets)) {
+        errors.push('subnets must be an array');
+    }
+    else {
+        errors.push(...(0, utils_1.validateArrayLength)({
+            value: vpcConfig.subnets,
+            min: 2,
+            max: 6,
+            messagePrefix: 'subnets ',
+        }));
+    }
+    return errors;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace-base.js","sourceRoot":"","sources":["../../src/validation/workspace-base.ts"],"names":[],"mappings":"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","sourcesContent":["import { validateArrayLength, validateNumberRange, validateRegExp, validateStringLength } from '@robhan-cdk-lib/utils';\nimport { NetworkAccessControl, SamlConfiguration, VpcConfiguration } from '../workspace-base';\n\n/**\n * Validates the clientToken property.\n *\n * @param token - The client token to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be a string\n * - Must be between 1 and 64 characters long\n * - Must contain only printable ASCII characters\n */\nexport function validateClientToken(token: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof token !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: token,\n    min: 1,\n    max: 64,\n  }));\n\n  errors.push(...validateRegExp({\n    value: token,\n    regExp: /^[!-~]*$/,\n    message: 'must contain only printable ASCII characters',\n  }));\n\n  return errors;\n}\n\n/**\n * Validates the description property.\n *\n * @param description - The description to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be a string\n * - Maximum length of 2048 characters\n */\nexport function validateDescription(description: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof description !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: description,\n    max: 2048,\n  }));\n\n  return errors;\n}\n\n/**\n * Validates the grafanaVersion property.\n *\n * @param version - The Grafana version to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be a string\n * - Must be between 1 and 255 characters long\n */\nexport function validateGrafanaVersion(version: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof version !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: version,\n    min: 1,\n    max: 255,\n  }));\n\n  return errors;\n}\n\n/**\n * Validates the name property.\n *\n * @param name - The workspace name to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be a string\n * - Must be between 1 and 255 characters long\n * - Can only contain alphanumeric characters, hyphens, dots, underscores, and tildes\n */\nexport function validateName(name: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof name !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateRegExp({\n    value: name,\n    regExp: /^[a-zA-Z0-9\\-._~]+$/,\n    message: 'can only contain alphanumeric characters, hyphens, dots, underscores, and tildes',\n  }));\n\n  errors.push(...validateStringLength({\n    value: name,\n    min: 1,\n    max: 255,\n  }));\n\n  return errors;\n}\n\n/**\n * Validates the networkAccessControl property.\n *\n * @param nac - The network access control configuration to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be an object\n * - prefixLists (if present) must be an array with at most 5 items\n * - vpcEndpoints (if present) must be an array with at most 5 items\n */\nexport function validateNetworkAccessControl(nac: unknown): string[] {\n  const errors: string[] = [];\n\n  if (!nac || typeof nac !== 'object') {\n    errors.push('must be an object');\n    return errors;\n  }\n\n  const networkAccessControl = nac as NetworkAccessControl;\n\n  // Check prefixLists if present\n  if (networkAccessControl.prefixLists !== undefined) {\n    if (!Array.isArray(networkAccessControl.prefixLists)) {\n      errors.push('prefixLists must be an array');\n    } else {\n      errors.push(...validateArrayLength({\n        value: networkAccessControl.prefixLists,\n        max: 5,\n        messagePrefix: 'prefixLists ',\n      }));\n    }\n  }\n\n  // Check vpcEndpoints if present\n  if (networkAccessControl.vpcEndpoints !== undefined) {\n    if (!Array.isArray(networkAccessControl.vpcEndpoints)) {\n      errors.push('vpcEndpoints must be an array');\n    } else {\n      errors.push(...validateArrayLength({\n        value: networkAccessControl.vpcEndpoints,\n        max: 5,\n        messagePrefix: 'vpcEndpoints ',\n      }));\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Validates the organizationRoleName property.\n *\n * @param roleName - The organization role name to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be a string\n * - Must be between 1 and 2048 characters long\n */\nexport function validateOrganizationRoleName(roleName: unknown): string[] {\n  const errors: string[] = [];\n\n  if (typeof roleName !== 'string') {\n    errors.push('must be a string');\n    return errors; // No need to check further if not a string\n  }\n\n  errors.push(...validateStringLength({\n    value: roleName,\n    min: 1,\n    max: 2048,\n  }));\n\n  return errors;\n}\n\n/**\n * Validates the SAML assertion attributes.\n *\n * @param obj - The SAML assertion attributes to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be an object\n * - Each attribute must be a string\n * - Each attribute must be between 1 and 256 characters long\n * - Valid attribute keys are: 'email', 'groups', 'login', 'name', 'org', 'role'\n */\nexport function validateSamlAssertionAttributes(obj: unknown): string[] {\n  const errors: string[] = [];\n\n  if (!obj || typeof obj !== 'object') {\n    return ['must be an object'];\n  }\n\n  const attributes = obj as Record<string, unknown>;\n\n  for (const key in attributes) {\n    const value = attributes[key];\n    if (value === undefined) {\n      continue; // Optional properties can be undefined\n    }\n\n    if (typeof value !== 'string') {\n      errors.push(`Property '${key}' must be a string`);\n    } else {\n      errors.push(...validateStringLength({\n        value,\n        min: 1,\n        max: 256,\n        messagePrefix: `Property '${key}' `,\n      }));\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Validates the SAML IdP metadata.\n *\n * @param obj - The SAML IdP metadata to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be an object\n * - url (if present) must be a string between 1 and 2048 characters long\n * - xml (if present) must be a string\n */\nexport function validateSamlIdpMetadata(obj: unknown): string[] {\n  const errors: string[] = [];\n\n  if (!obj || typeof obj !== 'object') {\n    return ['must be an object'];\n  }\n\n  const metadata = obj as Record<string, unknown>;\n\n  // Check url property if present\n  if (metadata.url !== undefined) {\n    if (typeof metadata.url !== 'string') {\n      errors.push(\"Property 'url' must be a string\");\n    } else {\n      errors.push(...validateStringLength({\n        value: metadata.url,\n        min: 1,\n        max: 2048,\n        messagePrefix: \"Property 'url' \",\n      }));\n    }\n  }\n\n  // Check xml property if present\n  if (metadata.xml !== undefined && typeof metadata.xml !== 'string') {\n    errors.push(\"Property 'xml' must be a string\");\n  }\n\n  return errors;\n}\n\n/**\n * Validates the SAML configuration.\n *\n * @param config - The SAML configuration to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be an object\n * - idpMetadata is required and must be valid\n * - assertionAtrributes (if present) must be valid\n * - allowedOrganizations (if present) must be an array of strings with 1-256 elements\n * - loginValidityDuration (if present) must be a positive number\n * - roleValues (if present) must be an object with valid admin and editor arrays\n */\nexport function validateSamlConfiguration(config: unknown): string[] {\n  const errors: string[] = [];\n\n  if (!config || typeof config !== 'object') {\n    errors.push('must be an object');\n    return errors;\n  }\n\n  const samlConfig = config as SamlConfiguration;\n\n  // Check idpMetadata (required)\n  if (samlConfig.idpMetadata === undefined) {\n    errors.push('idpMetadata is required in samlConfiguration');\n  } else {\n    const idpMetadataErrors = validateSamlIdpMetadata(\n      samlConfig.idpMetadata,\n    );\n    if (idpMetadataErrors.length > 0) {\n      errors.push(...idpMetadataErrors.map((err) => `idpMetadata: ${err}`));\n    }\n  }\n\n  // Check assertionAtrributes if present\n  if (samlConfig.assertionAtrributes !== undefined) {\n    const attributeErrors = validateSamlAssertionAttributes(\n      samlConfig.assertionAtrributes,\n    );\n    if (attributeErrors.length > 0) {\n      errors.push(\n        ...attributeErrors.map((err) => `assertionAtrributes: ${err}`),\n      );\n    }\n  }\n\n  // Check allowedOrganizations if present\n  if (samlConfig.allowedOrganizations !== undefined) {\n    if (!Array.isArray(samlConfig.allowedOrganizations)) {\n      errors.push('allowedOrganizations must be an array');\n    } else {\n      errors.push(\n        ...validateArrayLength({\n          value: samlConfig.allowedOrganizations,\n          min: 1,\n          max: 256,\n          messagePrefix: 'allowedOrganizations ',\n        }),\n      );\n\n      for (let i = 0; i < samlConfig.allowedOrganizations.length; i++) {\n        const org = samlConfig.allowedOrganizations[i];\n        if (typeof org !== 'string') {\n          errors.push(`allowedOrganizations[${i}] must be a string`);\n        }\n      }\n    }\n  }\n\n  // Check loginValidityDuration if present\n  if (samlConfig.loginValidityDuration !== undefined) {\n    if (typeof samlConfig.loginValidityDuration !== 'number') {\n      errors.push('loginValidityDuration must be a number');\n    } else {\n      errors.push(\n        ...validateNumberRange({\n          value: samlConfig.loginValidityDuration,\n          min: 1,\n          messagePrefix: 'loginValidityDuration ',\n        }),\n      );\n    }\n  }\n\n  // Check roleValues if present\n  if (samlConfig.roleValues !== undefined) {\n    if (!samlConfig.roleValues || typeof samlConfig.roleValues !== 'object') {\n      errors.push('roleValues must be an object');\n    } else {\n      // Check admin array if present\n      if (samlConfig.roleValues.admin !== undefined) {\n        if (!Array.isArray(samlConfig.roleValues.admin)) {\n          errors.push('roleValues.admin must be an array');\n        } else {\n          for (let i = 0; i < samlConfig.roleValues.admin.length; i++) {\n            if (typeof samlConfig.roleValues.admin[i] !== 'string') {\n              errors.push(`roleValues.admin[${i}] must be a string`);\n            }\n          }\n\n          errors.push(\n            ...validateArrayLength({\n              value: samlConfig.roleValues.admin,\n              max: 256,\n              messagePrefix: 'roleValues.admin ',\n            }),\n          );\n        }\n      }\n\n      // Check editor array if present\n      if (samlConfig.roleValues.editor !== undefined) {\n        if (!Array.isArray(samlConfig.roleValues.editor)) {\n          errors.push('roleValues.editor must be an array');\n        } else {\n          for (let i = 0; i < samlConfig.roleValues.editor.length; i++) {\n            if (typeof samlConfig.roleValues.editor[i] !== 'string') {\n              errors.push(`roleValues.editor[${i}] must be a string`);\n            }\n          }\n\n          errors.push(\n            ...validateArrayLength({\n              value: samlConfig.roleValues.editor,\n              max: 256,\n              messagePrefix: 'roleValues.editor ',\n            }),\n          );\n        }\n      }\n    }\n  }\n\n  return errors;\n}\n\n/**\n * Validates the vpcConfiguration property.\n *\n * @param config - The VPC configuration to validate\n * @returns An array of error messages if validation fails, or an empty array if valid\n *\n * Validation rules:\n * - Must be an object\n * - securityGroups is required and must be an array with 1-5 items\n * - subnets is required and must be an array with 2-6 items\n */\nexport function validateVpcConfiguration(config: unknown): string[] {\n  const errors: string[] = [];\n\n  if (!config || typeof config !== 'object') {\n    errors.push('vpcConfiguration must be an object');\n    return errors;\n  }\n\n  const vpcConfig = config as VpcConfiguration;\n\n  // Check securityGroups (required)\n  if (vpcConfig.securityGroups === undefined) {\n    errors.push('securityGroups is required in vpcConfiguration');\n  } else if (!Array.isArray(vpcConfig.securityGroups)) {\n    errors.push('securityGroups must be an array');\n  } else {\n    errors.push(\n      ...validateArrayLength({\n        value: vpcConfig.securityGroups,\n        min: 1,\n        max: 5,\n        messagePrefix: 'securityGroups ',\n      }),\n    );\n  }\n\n  // Check subnets (required)\n  if (vpcConfig.subnets === undefined) {\n    errors.push('subnets is required in vpcConfiguration');\n  } else if (!Array.isArray(vpcConfig.subnets)) {\n    errors.push('subnets must be an array');\n  } else {\n    errors.push(\n      ...validateArrayLength({\n        value: vpcConfig.subnets,\n        min: 2,\n        max: 6,\n        messagePrefix: 'subnets ',\n      }),\n    );\n  }\n\n  return errors;\n}"]}

package/lib/workspace-base.js

@@ -146,5 +146,5 @@ class WorkspaceBase extends aws_cdk_lib_1.Resource {
 }
 exports.WorkspaceBase = WorkspaceBase;
 _a = JSII_RTTI_SYMBOL_1;
-WorkspaceBase[_a] = { fqn: "@robhan-cdk-lib/aws_grafana.WorkspaceBase", version: "0.0.65" };
+WorkspaceBase[_a] = { fqn: "@robhan-cdk-lib/aws_grafana.WorkspaceBase", version: "0.0.66" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace-base.js","sourceRoot":"","sources":["../src/workspace-base.ts"],"names":[],"mappings":";;;;;AAAA,6CAAkD;AAIlD;;;;;GAKG;AACH,IAAY,iBAUX;AAVD,WAAY,iBAAiB;IAC3B;;OAEG;IACH,wDAAmC,CAAA;IAEnC;;OAEG;IACH,kDAA6B,CAAA;AAC/B,CAAC,EAVW,iBAAiB,iCAAjB,iBAAiB,QAU5B;AAED;;;;;GAKG;AACH,IAAY,uBAUX;AAVD,WAAY,uBAAuB;IACjC;;OAEG;IACH,8CAAmB,CAAA;IAEnB;;OAEG;IACH,wCAAa,CAAA;AACf,CAAC,EAVW,uBAAuB,uCAAvB,uBAAuB,QAUlC;AA2BD;;;GAGG;AACH,IAAY,wBAKX;AALD,WAAY,wBAAwB;IAClC;;OAEG;IACH,uCAAW,CAAA;AACb,CAAC,EALW,wBAAwB,wCAAxB,wBAAwB,QAKnC;AAED;;;;;;;;;;GAUG;AACH,IAAY,eAUX;AAVD,WAAY,eAAe;IACzB;;OAEG;IACH,wDAAqC,CAAA;IAErC;;OAEG;IACH,sDAAmC,CAAA;AACrC,CAAC,EAVW,eAAe,+BAAf,eAAe,QAU1B;AA4JD;;GAEG;AACH,IAAY,yBAUX;AAVD,WAAY,yBAAyB;IACnC;;OAEG;IACH,sDAAyB,CAAA;IAEzB;;OAEG;IACH,8DAAiC,CAAA;AACnC,CAAC,EAVW,yBAAyB,yCAAzB,yBAAyB,QAUpC;AAED;;GAEG;AACH,IAAY,MAuDX;AAvDD,WAAY,MAAM;IAChB;;OAEG;IACH,2BAAiB,CAAA;IAEjB;;OAEG;IACH,+BAAqB,CAAA;IAErB;;OAEG;IACH,+BAAqB,CAAA;IAErB;;OAEG;IACH,2BAAiB,CAAA;IAEjB;;OAEG;IACH,+BAAqB,CAAA;IAErB;;OAEG;IACH,iCAAuB,CAAA;IAEvB;;OAEG;IACH,6CAAmC,CAAA;IAEnC;;OAEG;IACH,6CAAmC,CAAA;IAEnC;;OAEG;IACH,yCAA+B,CAAA;IAE/B;;OAEG;IACH,2CAAiC,CAAA;IAEjC;;OAEG;IACH,2DAAiD,CAAA;AACnD,CAAC,EAvDW,MAAM,sBAAN,MAAM,QAuDjB;AA8HD,MAAsB,aAAc,SAAQ,sBAAQ;IAqGxC,eAAe,CAAC,WAAmB;QAC3C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,OAAO,OAAO,KAAK,CAAC,SAAS,YAAY,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,OAAO,eAAe,WAAW,EAAE,CAAC;IACrG,CAAC;IAES,cAAc,CAAC,YAAoB;QAC3C,OAAO,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC,WAAW,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACnE,CAAC;;AA5GH,sCA6GC","sourcesContent":["import { IResource, Resource } from 'aws-cdk-lib';\nimport { IPrefixList, ISecurityGroup, ISubnet, IVpcEndpoint } from 'aws-cdk-lib/aws-ec2';\nimport { IRole } from 'aws-cdk-lib/aws-iam';\n\n/**\n * Specifies whether the workspace can access AWS resources in this AWS account only, or whether it\n * can also access AWS resources in other accounts in the same organization. If this is\n * ORGANIZATION, the OrganizationalUnits parameter specifies which organizational units the\n * workspace can access.\n */\nexport enum AccountAccessType {\n  /**\n   * Access is limited to the current AWS account only.\n   */\n  CURRENT_ACCOUNT = 'CURRENT_ACCOUNT',\n\n  /**\n   * Access is extended to the entire AWS organization.\n   */\n  ORGANIZATION = 'ORGANIZATION',\n}\n\n/**\n * Specifies whether this workspace uses SAML 2.0, AWS IAM Identity Center, or both to authenticate\n * users for using the Grafana console within a workspace.\n *\n * @see https://docs.aws.amazon.com/grafana/latest/APIReference/API_CreateWorkspace.html\n */\nexport enum AuthenticationProviders {\n  /**\n   * AWS Single Sign-On authentication provider.\n   */\n  AWS_SSO = 'AWS_SSO',\n\n  /**\n   * Security Assertion Markup Language (SAML) authentication provider.\n   */\n  SAML = 'SAML',\n}\n\n/**\n * The configuration settings for network access to your workspace.\n */\nexport interface NetworkAccessControl {\n  /**\n   * An array of prefix list IDs. A prefix list is a list of CIDR ranges of IP addresses. The IP\n   * addresses specified are allowed to access your workspace. If the list is not included in the\n   * configuration (passed an empty array) then no IP addresses are allowed to access the\n   * workspace.\n   *\n   * Maximum of 5 prefix lists allowed.\n   */\n  readonly prefixLists?: IPrefixList[];\n\n  /**\n   * An array of Amazon VPC endpoint IDs for the workspace. You can create VPC endpoints to your\n   * Amazon Managed Grafana workspace for access from within a VPC. If a NetworkAccessConfiguration\n   * is specified then only VPC endpoints specified here are allowed to access the workspace. If\n   * you pass in an empty array of strings, then no VPCs are allowed to access the workspace.\n   *\n   * Maximum of 5 VPC endpoints allowed.\n   */\n  readonly vpcEndpoints?: IVpcEndpoint[];\n}\n\n/**\n * The AWS notification channels that Amazon Managed Grafana can automatically create IAM roles and\n * permissions for, to allow Amazon Managed Grafana to use these channels.\n */\nexport enum NotificationDestinations {\n  /**\n   * Amazon Simple Notification Service (SNS) as notification destination.\n   */\n  SNS = 'SNS',\n}\n\n/**\n * If this is SERVICE_MANAGED, and the workplace was created through the Amazon Managed Grafana\n * console, then Amazon Managed Grafana automatically creates the IAM roles and provisions the\n * permissions that the workspace needs to use AWS data sources and notification channels.\n *\n * If this is CUSTOMER_MANAGED, you must manage those roles and permissions yourself.\n\n * If you are working with a workspace in a member account of an organization and that account is\n * not a delegated administrator account, and you want the workspace to access data sources in\n * other AWS accounts in the organization, this parameter must be set to CUSTOMER_MANAGED.\n */\nexport enum PermissionTypes {\n  /**\n   * Customer-managed permissions where you manage user access to Grafana.\n   */\n  CUSTOMER_MANAGED = 'CUSTOMER_MANAGED',\n\n  /**\n   * Service-managed permissions where AWS manages user access to Grafana.\n   */\n  SERVICE_MANAGED = 'SERVICE_MANAGED',\n}\n\n/**\n * A structure that defines which attributes in the IdP assertion are to be used to define\n * information about the users authenticated by the IdP to use the workspace.\n *\n * Each attribute must be a string with length between 1 and 256 characters.\n */\nexport interface SamlAssertionAttributes {\n  /**\n   * The name of the attribute within the SAML assertion to use as the email names for SAML users.\n   *\n   * Must be between 1 and 256 characters long.\n   */\n  readonly email?: string;\n  /**\n   * The name of the attribute within the SAML assertion to use as the user full \"friendly\" names\n   * for user groups.\n   *\n   * Must be between 1 and 256 characters long.\n   */\n  readonly groups?: string;\n  /**\n   * The name of the attribute within the SAML assertion to use as the login names for SAML users.\n   *\n   * Must be between 1 and 256 characters long.\n   */\n  readonly login?: string;\n  /**\n   * The name of the attribute within the SAML assertion to use as the user full \"friendly\" names\n   * for SAML users.\n   *\n   * Must be between 1 and 256 characters long.\n   */\n  readonly name?: string;\n  /**\n   * The name of the attribute within the SAML assertion to use as the user full \"friendly\" names\n   * for the users' organizations.\n   *\n   * Must be between 1 and 256 characters long.\n   */\n  readonly org?: string;\n  /**\n   * The name of the attribute within the SAML assertion to use as the user roles.\n   *\n   * Must be between 1 and 256 characters long.\n   */\n  readonly role?: string;\n}\n\n/**\n * A structure containing the identity provider (IdP) metadata used to integrate the identity\n * provider with this workspace.\n */\nexport interface SamlIdpMetadata {\n  /**\n   * The URL of the location containing the IdP metadata.\n   *\n   * Must be a string with length between 1 and 2048 characters.\n   */\n  readonly url?: string;\n\n  /**\n   * The full IdP metadata, in XML format.\n   */\n  readonly xml?: string;\n}\n\n/**\n * A structure containing arrays that map group names in the SAML assertion to the Grafana Admin\n * and Editor roles in the workspace.\n */\nexport interface SamlRoleValues {\n  /**\n   * A list of groups from the SAML assertion attribute to grant the Grafana Admin role to.\n   *\n   * Maximum of 256 elements.\n   */\n  readonly admin?: string[];\n\n  /**\n   * A list of groups from the SAML assertion attribute to grant the Grafana Editor role to.\n   *\n   * Maximum of 256 elements.\n   */\n  readonly editor?: string[];\n}\n\n/**\n * If the workspace uses SAML, use this structure to map SAML assertion attributes to workspace\n * user information and define which groups in the assertion attribute are to have the Admin and\n * Editor roles in the workspace.\n */\nexport interface SamlConfiguration {\n  /**\n   * Lists which organizations defined in the SAML assertion are allowed to use the Amazon Managed\n   * Grafana workspace. If this is empty, all organizations in the assertion attribute have access.\n   *\n   * Must have between 1 and 256 elements.\n   */\n  readonly allowedOrganizations?: string[];\n\n  /**\n   * A structure that defines which attributes in the SAML assertion are to be used to define\n   * information about the users authenticated by that IdP to use the workspace.\n   */\n  readonly assertionAtrributes?: SamlAssertionAttributes;\n\n  /**\n   * A structure containing the identity provider (IdP) metadata used to integrate the identity\n   * provider with this workspace.\n   *\n   * Required field for SAML configuration.\n   */\n  readonly idpMetadata: SamlIdpMetadata;\n\n  /**\n   * How long a sign-on session by a SAML user is valid, before the user has to sign on again.\n   *\n   * Must be a positive number.\n   */\n  readonly loginValidityDuration?: number;\n\n  /**\n   * A structure containing arrays that map group names in the SAML assertion to the Grafana Admin\n   * and Editor roles in the workspace.\n   */\n  readonly roleValues?: SamlRoleValues;\n}\n\n/**\n * The configuration settings for an Amazon VPC that contains data sources for your Grafana\n * workspace to connect to.\n */\nexport interface VpcConfiguration {\n  /**\n   * The list of Amazon EC2 security groups attached to the Amazon VPC for your Grafana\n   * workspace to connect. Duplicates not allowed.\n   *\n   * Array Members: Minimum number of 1 items. Maximum number of 5 items.\n   *\n   * Required for VPC configuration.\n   */\n  readonly securityGroups: ISecurityGroup[];\n\n  /**\n   * The list of Amazon EC2 subnets created in the Amazon VPC for your Grafana workspace to\n   * connect. Duplicates not allowed.\n   *\n   * Array Members: Minimum number of 2 items. Maximum number of 6 items.\n   *\n   * Required for VPC configuration.\n   */\n  readonly subnets: ISubnet[];\n}\n\n/**\n * Status of SAML configuration for a Grafana workspace.\n */\nexport enum SamlConfigurationStatuses {\n  /**\n   * SAML is configured for the workspace.\n   */\n  CONFIGURED = 'CONFIGURED',\n\n  /**\n   * SAML is not configured for the workspace.\n   */\n  NOT_CONFIGURED = 'NOT_CONFIGURED',\n}\n\n/**\n * Status of a Grafana workspace.\n */\nexport enum Status {\n  /**\n   * Workspace is active and ready to use.\n   */\n  ACTIVE = 'ACTIVE',\n\n  /**\n   * Workspace is being created.\n   */\n  CREATING = 'CREATING',\n\n  /**\n   * Workspace is being deleted.\n   */\n  DELETING = 'DELETING',\n\n  /**\n   * Workspace operation has failed.\n   */\n  FAILED = 'FAILED',\n\n  /**\n   * Workspace is being updated.\n   */\n  UPDATING = 'UPDATING',\n\n  /**\n   * Workspace is being upgraded.\n   */\n  UPGRADING = 'UPGRADING',\n\n  /**\n   * Workspace deletion has failed.\n   */\n  DELETION_FAILED = 'DELETION_FAILED',\n\n  /**\n   * Workspace creation has failed.\n   */\n  CREATION_FAILED = 'CREATION_FAILED',\n\n  /**\n   * Workspace update has failed.\n   */\n  UPDATE_FAILED = 'UPDATE_FAILED',\n\n  /**\n   * Workspace upgrade has failed.\n   */\n  UPGRADE_FAILED = 'UPGRADE_FAILED',\n\n  /**\n   * License removal has failed.\n   */\n  LICENSE_REMOVAL_FAILED = 'LICENSE_REMOVAL_FAILED',\n}\n\n/**\n * Represents an Amazon Managed Service for Grafana workspace\n */\nexport interface IWorkspace extends IResource {\n\n  /**\n   * Specifies whether the workspace can access AWS resources in this AWS account only, or whether\n   * it can also access AWS resources in other accounts in the same organization. If this is\n   * ORGANIZATION, the OrganizationalUnits parameter specifies which organizational units the\n   * workspace can access.\n   */\n  readonly accountAccessType: AccountAccessType;\n\n  /**\n   * Specifies whether this workspace uses SAML 2.0, AWS IAM Identity Center, or both to\n   * authenticate users for using the Grafana console within a workspace.\n   */\n  readonly authenticationProviders: AuthenticationProviders[];\n\n  /**\n   * A unique, case-sensitive, user-provided identifier to ensure the idempotency of the request.\n   */\n  readonly clientToken?: string;\n\n  /**\n   * Specifies the AWS data sources that have been configured to have IAM roles and permissions\n   * created to allow Amazon Managed Grafana to read data from these sources.\n   *\n   * This list is only used when the workspace was created through the AWS console, and the\n   * permissionType is SERVICE_MANAGED.\n   */\n  readonly dataSources?: string[];\n\n  /**\n   * The user-defined description of the workspace.\n   */\n  readonly description?: string;\n\n  /**\n   * The name of the workspace.\n   */\n  readonly name?: string;\n\n  /**\n   * The configuration settings for network access to your workspace.\n   */\n  readonly networkAccessControl?: NetworkAccessControl;\n\n  /**\n   * The AWS notification channels that Amazon Managed Grafana can automatically create IAM roles\n   * and permissions for, to allow Amazon Managed Grafana to use these channels.\n   */\n  readonly notificationDestinations?: NotificationDestinations[];\n\n  /**\n   * Specifies the organizational units that this workspace is allowed to use data sources from, if\n   * this workspace is in an account that is part of an organization.\n   */\n  readonly organizationalUnits?: string[];\n\n  /**\n   * The name of the IAM role that is used to access resources through Organizations.\n   */\n  readonly organizationRoleName?: string;\n\n  /**\n   * If this is SERVICE_MANAGED, and the workplace was created through the Amazon Managed Grafana\n   * console, then Amazon Managed Grafana automatically creates the IAM roles and provisions the\n   * permissions that the workspace needs to use AWS data sources and notification channels.\n   *\n   * If this is CUSTOMER_MANAGED, you must manage those roles and permissions yourself.\n   *\n   * If you are working with a workspace in a member account of an organization and that account is\n   * not a delegated administrator account, and you want the workspace to access data sources in\n   * other AWS accounts in the organization, this parameter must be set to CUSTOMER_MANAGED.\n   */\n  readonly permissionType: PermissionTypes;\n\n  /**\n   * Whether plugin administration is enabled in the workspace. Setting to true allows workspace\n   * admins to install, uninstall, and update plugins from within the Grafana workspace.\n   *\n   * This option is only valid for workspaces that support Grafana version 9 or newer.\n   */\n  readonly pluginAdminEnabled?: boolean;\n\n  /**\n   * The IAM role that grants permissions to the AWS resources that the workspace will view data\n   * from.\n   */\n  readonly role?: IRole;\n\n  /**\n   * If the workspace uses SAML, use this structure to map SAML assertion attributes to workspace\n   * user information and define which groups in the assertion attribute are to have the Admin and\n   * Editor roles in the workspace.\n   */\n  readonly samlConfiguration?: SamlConfiguration;\n\n  /**\n   * The name of the AWS CloudFormation stack set that is used to generate IAM roles to be used for\n   * this workspace.\n   */\n  readonly stackSetName?: string;\n\n  /**\n   * The configuration settings for an Amazon VPC that contains data sources for your Grafana\n   * workspace to connect to.\n   */\n  readonly vpcConfiguration?: VpcConfiguration;\n\n  /**\n   * The unique ID of this workspace.\n   * @attribute\n   */\n  readonly workspaceId: string;\n\n  /**\n   * The ARN of this workspace\n   * @attribute\n   */\n  readonly workspaceArn: string;\n}\n\nexport abstract class WorkspaceBase extends Resource implements IWorkspace {\n\n  /**\n   * The account access type for the workspace.\n   */\n  public abstract readonly accountAccessType: AccountAccessType;\n\n  /**\n   * The authentication providers for the workspace.\n   */\n  public abstract readonly authenticationProviders: AuthenticationProviders[];\n\n  /**\n   * The client token for the workspace.\n   */\n  public abstract readonly clientToken?: string;\n\n  /**\n   * The data sources of this workspace\n   */\n  public abstract readonly dataSources?: string[];\n\n  /**\n   * The description of this workspace\n   */\n  public abstract readonly description?: string;\n\n  /**\n   * The name of this workspace\n   */\n  public abstract readonly name?: string;\n\n  /**\n   * The configuration settings for network access to your workspace.\n   */\n  public abstract readonly networkAccessControl?: NetworkAccessControl;\n\n  /**\n   * The notification destinations for the workspace.\n   */\n  public abstract readonly notificationDestinations?: NotificationDestinations[];\n\n  /**\n   * Specifies the organizational units that this workspace is allowed to use data sources from, if\n   * this workspace is in an account that is part of an organization.\n   */\n  public abstract readonly organizationalUnits?: string[];\n\n  /**\n   * The name of the IAM role that is used to access resources through Organizations.\n   */\n  public abstract readonly organizationRoleName?: string;\n\n  /**\n   * The permission type for the workspace.\n   */\n  public abstract readonly permissionType: PermissionTypes;\n\n  /**\n   * Whether plugin administration is enabled in the workspace. Setting to true allows workspace\n   * admins to install, uninstall, and update plugins from within the Grafana workspace.\n   *\n   * This option is only valid for workspaces that support Grafana version 9 or newer.\n   */\n  public abstract readonly pluginAdminEnabled?: boolean;\n\n  /**\n   * The IAM role that grants permissions to the AWS resources that the workspace will view data\n   * from.\n   */\n  public abstract readonly role?: IRole;\n\n  /**\n   * If the workspace uses SAML, use this structure to map SAML assertion attributes to workspace\n   * user information and define which groups in the assertion attribute are to have the Admin and\n   * Editor roles in the workspace.\n   */\n  public abstract readonly samlConfiguration?: SamlConfiguration;\n\n  /**\n   * The name of the AWS CloudFormation stack set that is used to generate IAM roles to be used for\n   * this workspace.\n   */\n  public abstract readonly stackSetName?: string;\n\n  /**\n   * The configuration settings for an Amazon VPC that contains data sources for your Grafana\n   * workspace to connect to.\n   */\n  public abstract readonly vpcConfiguration?: VpcConfiguration;\n\n  /**\n   * The unique ID of this workspace.\n   */\n  public abstract readonly workspaceId: string;\n\n  /**\n   * The ARN of this workspace\n   */\n  public abstract readonly workspaceArn: string;\n\n  protected getWorkspaceArn(workspaceId: string) {\n    const stack = this.stack;\n    return `arn:${stack.partition}:grafana:${stack.region}:${stack.account}:workspaces/${workspaceId}`;\n  }\n\n  protected getWorkspaceId(workspaceArn: string) {\n    return workspaceArn.substring(workspaceArn.lastIndexOf('/') + 1);\n  }\n}"]}