@robhan-cdk-lib/aws_grafana 0.0.0

package/lib/workspace.js

@@ -0,0 +1,694 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workspace = exports.Status = exports.SamlConfigurationStatuses = exports.PermissionTypes = exports.NotificationDestinations = exports.AuthenticationProviders = exports.AccountAccessType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_grafana_1 = require("aws-cdk-lib/aws-grafana");
+const constructs_1 = require("constructs");
+/**
+ * Specifies whether the workspace can access AWS resources in this AWS account only, or whether it
+ * can also access AWS resources in other accounts in the same organization. If this is
+ * ORGANIZATION, the OrganizationalUnits parameter specifies which organizational units the
+ * workspace can access.
+ */
+var AccountAccessType;
+(function (AccountAccessType) {
+    /**
+     * Access is limited to the current AWS account only.
+     */
+    AccountAccessType["CURRENT_ACCOUNT"] = "CURRENT_ACCOUNT";
+    /**
+     * Access is extended to the entire AWS organization.
+     */
+    AccountAccessType["ORGANIZATION"] = "ORGANIZATION";
+})(AccountAccessType || (exports.AccountAccessType = AccountAccessType = {}));
+/**
+ * Specifies whether this workspace uses SAML 2.0, AWS IAM Identity Center, or both to authenticate
+ * users for using the Grafana console within a workspace.
+ *
+ * @see https://docs.aws.amazon.com/grafana/latest/APIReference/API_CreateWorkspace.html
+ */
+var AuthenticationProviders;
+(function (AuthenticationProviders) {
+    /**
+     * AWS Single Sign-On authentication provider.
+     */
+    AuthenticationProviders["AWS_SSO"] = "AWS_SSO";
+    /**
+     * Security Assertion Markup Language (SAML) authentication provider.
+     */
+    AuthenticationProviders["SAML"] = "SAML";
+})(AuthenticationProviders || (exports.AuthenticationProviders = AuthenticationProviders = {}));
+/**
+ * The AWS notification channels that Amazon Managed Grafana can automatically create IAM roles and
+ * permissions for, to allow Amazon Managed Grafana to use these channels.
+ */
+var NotificationDestinations;
+(function (NotificationDestinations) {
+    /**
+     * Amazon Simple Notification Service (SNS) as notification destination.
+     */
+    NotificationDestinations["SNS"] = "SNS";
+})(NotificationDestinations || (exports.NotificationDestinations = NotificationDestinations = {}));
+/**
+ * If this is SERVICE_MANAGED, and the workplace was created through the Amazon Managed Grafana
+ * console, then Amazon Managed Grafana automatically creates the IAM roles and provisions the
+ * permissions that the workspace needs to use AWS data sources and notification channels.
+ *
+ * If this is CUSTOMER_MANAGED, you must manage those roles and permissions yourself.
+
+ * If you are working with a workspace in a member account of an organization and that account is
+ * not a delegated administrator account, and you want the workspace to access data sources in
+ * other AWS accounts in the organization, this parameter must be set to CUSTOMER_MANAGED.
+ */
+var PermissionTypes;
+(function (PermissionTypes) {
+    /**
+     * Customer-managed permissions where you manage user access to Grafana.
+     */
+    PermissionTypes["CUSTOMER_MANAGED"] = "CUSTOMER_MANAGED";
+    /**
+     * Service-managed permissions where AWS manages user access to Grafana.
+     */
+    PermissionTypes["SERVICE_MANAGED"] = "SERVICE_MANAGED";
+})(PermissionTypes || (exports.PermissionTypes = PermissionTypes = {}));
+/**
+ * Status of SAML configuration for a Grafana workspace.
+ */
+var SamlConfigurationStatuses;
+(function (SamlConfigurationStatuses) {
+    /**
+     * SAML is configured for the workspace.
+     */
+    SamlConfigurationStatuses["CONFIGURED"] = "CONFIGURED";
+    /**
+     * SAML is not configured for the workspace.
+     */
+    SamlConfigurationStatuses["NOT_CONFIGURED"] = "NOT_CONFIGURED";
+})(SamlConfigurationStatuses || (exports.SamlConfigurationStatuses = SamlConfigurationStatuses = {}));
+/**
+ * Status of a Grafana workspace.
+ */
+var Status;
+(function (Status) {
+    /**
+     * Workspace is active and ready to use.
+     */
+    Status["ACTIVE"] = "ACTIVE";
+    /**
+     * Workspace is being created.
+     */
+    Status["CREATING"] = "CREATING";
+    /**
+     * Workspace is being deleted.
+     */
+    Status["DELETING"] = "DELETING";
+    /**
+     * Workspace operation has failed.
+     */
+    Status["FAILED"] = "FAILED";
+    /**
+     * Workspace is being updated.
+     */
+    Status["UPDATING"] = "UPDATING";
+    /**
+     * Workspace is being upgraded.
+     */
+    Status["UPGRADING"] = "UPGRADING";
+    /**
+     * Workspace deletion has failed.
+     */
+    Status["DELETION_FAILED"] = "DELETION_FAILED";
+    /**
+     * Workspace creation has failed.
+     */
+    Status["CREATION_FAILED"] = "CREATION_FAILED";
+    /**
+     * Workspace update has failed.
+     */
+    Status["UPDATE_FAILED"] = "UPDATE_FAILED";
+    /**
+     * Workspace upgrade has failed.
+     */
+    Status["UPGRADE_FAILED"] = "UPGRADE_FAILED";
+    /**
+     * License removal has failed.
+     */
+    Status["LICENSE_REMOVAL_FAILED"] = "LICENSE_REMOVAL_FAILED";
+})(Status || (exports.Status = Status = {}));
+/**
+ * Represents an Amazon Managed Grafana workspace.
+ *
+ * This class provides a high-level abstraction for creating and managing
+ * Amazon Managed Grafana workspaces using AWS CDK.
+ */
+class Workspace extends constructs_1.Construct {
+    /**
+     * 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
+     */
+    static validateClientToken(token) {
+        const errors = [];
+        if (token === undefined) {
+            return errors; // Optional property can be undefined
+        }
+        if (typeof token !== 'string') {
+            errors.push('clientToken must be a string');
+            return errors; // No need to check further if not a string
+        }
+        const regex = /^[!-~]{1,64}$/;
+        if (!regex.test(token)) {
+            if (token.length < 1 || token.length > 64) {
+                errors.push('clientToken must be between 1 and 64 characters long');
+            }
+            if (!/^[!-~]*$/.test(token)) {
+                errors.push('clientToken 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
+     */
+    static validateDescription(description) {
+        const errors = [];
+        if (description === undefined) {
+            return errors; // Optional property can be undefined
+        }
+        if (typeof description !== 'string') {
+            errors.push('description must be a string');
+            return errors; // No need to check further if not a string
+        }
+        if (description.length > 2048) {
+            errors.push('description cannot exceed 2048 characters');
+        }
+        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
+     */
+    static validateGrafanaVersion(version) {
+        const errors = [];
+        if (version === undefined) {
+            return errors; // Optional property can be undefined
+        }
+        if (typeof version !== 'string') {
+            errors.push('grafanaVersion must be a string');
+            return errors; // No need to check further if not a string
+        }
+        if (version.length < 1) {
+            errors.push('grafanaVersion cannot be empty');
+        }
+        if (version.length > 255) {
+            errors.push('grafanaVersion cannot exceed 255 characters');
+        }
+        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
+     */
+    static validateName(name) {
+        const errors = [];
+        if (name === undefined) {
+            return errors; // Optional property can be undefined
+        }
+        if (typeof name !== 'string') {
+            errors.push('name must be a string');
+            return errors; // No need to check further if not a string
+        }
+        const regex = /^[a-zA-Z0-9\-._~]{1,255}$/;
+        if (!regex.test(name)) {
+            if (name.length < 1 || name.length > 255) {
+                errors.push('name must be between 1 and 255 characters long');
+            }
+            if (!/^[a-zA-Z0-9\-._~]*$/.test(name)) {
+                errors.push('name can only contain alphanumeric characters, hyphens, dots, underscores, and tildes');
+            }
+        }
+        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
+     */
+    static validateNetworkAccessControl(nac) {
+        const errors = [];
+        if (nac === undefined) {
+            return errors; // Optional property can be undefined
+        }
+        if (!nac || typeof nac !== 'object') {
+            errors.push('networkAccessControl 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 if (networkAccessControl.prefixLists.length > 5) {
+                errors.push('prefixLists can have at most 5 items');
+            }
+        }
+        // Check vpcEndpoints if present
+        if (networkAccessControl.vpcEndpoints !== undefined) {
+            if (!Array.isArray(networkAccessControl.vpcEndpoints)) {
+                errors.push('vpcEndpoints must be an array');
+            }
+            else if (networkAccessControl.vpcEndpoints.length > 5) {
+                errors.push('vpcEndpoints can have at most 5 items');
+            }
+        }
+        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
+     */
+    static validateOrganizationRoleName(roleName) {
+        const errors = [];
+        if (roleName === undefined) {
+            return errors; // Optional property can be undefined
+        }
+        if (typeof roleName !== 'string') {
+            errors.push('organizationRoleName must be a string');
+            return errors; // No need to check further if not a string
+        }
+        if (roleName.length < 1) {
+            errors.push('organizationRoleName cannot be empty');
+        }
+        if (roleName.length > 2048) {
+            errors.push('organizationRoleName cannot exceed 2048 characters');
+        }
+        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'
+     */
+    static validateSamlAssertionAttributes(obj) {
+        const errors = [];
+        if (!obj || typeof obj !== 'object') {
+            return ['Input is not 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 if (value.length < 1) {
+                errors.push(`Property '${key}' cannot be empty`);
+            }
+            else if (value.length > 256) {
+                errors.push(`Property '${key}' exceeds maximum length of 256 characters`);
+            }
+        }
+        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
+     */
+    static validateSamlIdpMetadata(obj) {
+        const errors = [];
+        if (!obj || typeof obj !== 'object') {
+            return ['Input is not 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 if (metadata.url.length < 1) {
+                errors.push("Property 'url' cannot be empty");
+            }
+            else if (metadata.url.length > 2048) {
+                errors.push("Property 'url' exceeds maximum length of 2048 characters");
+            }
+        }
+        // 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
+     */
+    static validateSamlConfiguration(config) {
+        const errors = [];
+        if (config === undefined) {
+            return errors; // Optional property can be undefined
+        }
+        if (!config || typeof config !== 'object') {
+            errors.push('samlConfiguration 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 = Workspace.validateSamlIdpMetadata(samlConfig.idpMetadata);
+            if (idpMetadataErrors.length > 0) {
+                errors.push(...idpMetadataErrors.map((err) => `idpMetadata: ${err}`));
+            }
+        }
+        // Check assertionAtrributes if present
+        if (samlConfig.assertionAtrributes !== undefined) {
+            const attributeErrors = Workspace.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 {
+                if (samlConfig.allowedOrganizations.length < 1) {
+                    errors.push('allowedOrganizations must have at least 1 element');
+                }
+                if (samlConfig.allowedOrganizations.length > 256) {
+                    errors.push('allowedOrganizations cannot have more than 256 elements');
+                }
+                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 if (samlConfig.loginValidityDuration <= 0) {
+                errors.push('loginValidityDuration must be positive');
+            }
+        }
+        // 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`);
+                            }
+                        }
+                    }
+                }
+                // 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`);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        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
+     */
+    static validateVpcConfiguration(config) {
+        const errors = [];
+        if (config === undefined) {
+            return errors; // Optional property can be undefined
+        }
+        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 {
+            if (vpcConfig.securityGroups.length < 1) {
+                errors.push('securityGroups must have at least 1 item');
+            }
+            if (vpcConfig.securityGroups.length > 5) {
+                errors.push('securityGroups cannot have more than 5 items');
+            }
+        }
+        // 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 {
+            if (vpcConfig.subnets.length < 2) {
+                errors.push('subnets must have at least 2 items');
+            }
+            if (vpcConfig.subnets.length > 6) {
+                errors.push('subnets cannot have more than 6 items');
+            }
+        }
+        return errors;
+    }
+    /**
+     * Validates all workspace properties.
+     *
+     * @param props - The workspace properties to validate
+     * @returns An array of error messages if validation fails, or an empty array if valid
+     *
+     * This method aggregates validation results from all individual property validators.
+     * It throws an error if props is not an object.
+     */
+    static validateProps(props) {
+        const errors = [];
+        if (!props || typeof props !== 'object') {
+            throw new Error('Props is not an object');
+        }
+        const workspaceProps = props;
+        if (workspaceProps.clientToken !== undefined) {
+            const clientTokenErrors = Workspace.validateClientToken(workspaceProps.clientToken);
+            if (clientTokenErrors.length > 0) {
+                errors.push(...clientTokenErrors.map((err) => `clientToken: ${err}`));
+            }
+        }
+        if (workspaceProps.description !== undefined) {
+            const descriptionErrors = Workspace.validateDescription(workspaceProps.description);
+            if (descriptionErrors.length > 0) {
+                errors.push(...descriptionErrors.map((err) => `description: ${err}`));
+            }
+        }
+        if (workspaceProps.grafanaVersion !== undefined) {
+            const grafanaVersionErrors = Workspace.validateGrafanaVersion(workspaceProps.grafanaVersion);
+            if (grafanaVersionErrors.length > 0) {
+                errors.push(...grafanaVersionErrors.map((err) => `grafanaVersion: ${err}`));
+            }
+        }
+        if (workspaceProps.name !== undefined) {
+            const nameErrors = Workspace.validateName(workspaceProps.name);
+            if (nameErrors.length > 0) {
+                errors.push(...nameErrors.map((err) => `name: ${err}`));
+            }
+        }
+        if (workspaceProps.networkAccessControl !== undefined) {
+            const networkAccessControlErrors = Workspace.validateNetworkAccessControl(workspaceProps.networkAccessControl);
+            if (networkAccessControlErrors.length > 0) {
+                errors.push(...networkAccessControlErrors.map((err) => `networkAccessControl: ${err}`));
+            }
+        }
+        if (workspaceProps.organizationRoleName !== undefined) {
+            const organizationRoleNameErrors = Workspace.validateOrganizationRoleName(workspaceProps.organizationRoleName);
+            if (organizationRoleNameErrors.length > 0) {
+                errors.push(...organizationRoleNameErrors.map((err) => `organizationRoleName: ${err}`));
+            }
+        }
+        if (workspaceProps.samlConfiguration !== undefined) {
+            const samlConfigurationErrors = Workspace.validateSamlConfiguration(workspaceProps.samlConfiguration);
+            if (samlConfigurationErrors.length > 0) {
+                errors.push(...samlConfigurationErrors.map((err) => `samlConfiguration: ${err}`));
+            }
+        }
+        if (workspaceProps.vpcConfiguration !== undefined) {
+            const vpcConfigurationErrors = Workspace.validateVpcConfiguration(workspaceProps.vpcConfiguration);
+            if (vpcConfigurationErrors.length > 0) {
+                errors.push(...vpcConfigurationErrors.map((err) => `vpcConfiguration: ${err}`));
+            }
+        }
+        return errors;
+    }
+    /**
+     * Creates a new Amazon Managed Grafana workspace.
+     *
+     * @param scope - The scope in which to define this construct
+     * @param id - The scoped construct ID
+     * @param props - Configuration properties for the workspace
+     *
+     * @throws Error if any of the provided properties fail validation
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        const errors = Workspace.validateProps(props);
+        if (errors.length > 0) {
+            throw new Error(`Invalid props:\n${errors.join('\n')}`);
+        }
+        if (props.accountAccessType === AccountAccessType.CURRENT_ACCOUNT &&
+            !props.role) {
+            throw new Error('Role must be provided when accountAccessType is CURRENT_ACCOUNT');
+        }
+        this.accountAccessType = props.accountAccessType;
+        this.authenticationProviders = props.authenticationProviders;
+        this.clientToken = props.clientToken;
+        this.dataSources = props.dataSources;
+        this.description = props.description;
+        this.networkAccessControl = props.networkAccessControl;
+        this.notificationDestinations = props.notificationDestinations;
+        this.organizationalUnits = props.organizationalUnits;
+        this.organizationRoleName = props.organizationRoleName;
+        this.permissionType = props.permissionType;
+        this.pluginAdminEnabled = props.pluginAdminEnabled;
+        this.name = props.name;
+        this.role = props.role;
+        this.samlConfiguration = props.samlConfiguration;
+        this.stackSetName = props.stackSetName;
+        this.vpcConfiguration = props.vpcConfiguration;
+        let cfnWorkspaceProps = {
+            accountAccessType: props.accountAccessType,
+            authenticationProviders: props.authenticationProviders,
+            clientToken: props.clientToken,
+            dataSources: props.dataSources,
+            description: props.description,
+            grafanaVersion: props.grafanaVersion,
+            name: props.name,
+            notificationDestinations: props.notificationDestinations,
+            organizationalUnits: props.organizationalUnits,
+            organizationRoleName: props.organizationRoleName,
+            permissionType: props.permissionType,
+            pluginAdminEnabled: props.pluginAdminEnabled,
+            roleArn: props.role?.roleArn,
+            samlConfiguration: props.samlConfiguration,
+            stackSetName: props.stackSetName,
+            vpcConfiguration: props.vpcConfiguration
+                ? {
+                    securityGroupIds: props.vpcConfiguration.securityGroups.map((sg) => sg.securityGroupId),
+                    subnetIds: props.vpcConfiguration.subnets.map((subnet) => subnet.subnetId),
+                }
+                : undefined,
+        };
+        this.workspace = new aws_grafana_1.CfnWorkspace(this, 'Resource', cfnWorkspaceProps);
+        this.creationTimestamp = this.workspace.attrCreationTimestamp;
+        this.endpoint = this.workspace.attrEndpoint;
+        this.grafanaVersion = this.workspace.attrGrafanaVersion;
+        this.id = this.workspace.attrId;
+        this.modificationTimestamp = this.workspace.attrModificationTimestamp;
+        this.samlConfigurationStatus = this.workspace
+            .attrSamlConfigurationStatus;
+        this.ssoClientId = this.workspace.attrSsoClientId;
+        this.status = this.workspace.attrStatus;
+    }
+}
+exports.Workspace = Workspace;
+_a = JSII_RTTI_SYMBOL_1;
+Workspace[_a] = { fqn: "@robhan-cdk-lib/aws_grafana.Workspace", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../src/workspace.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  IPrefixList,\n  ISecurityGroup,\n  ISubnet,\n  IVpcEndpoint,\n} from 'aws-cdk-lib/aws-ec2';\nimport { CfnWorkspace, CfnWorkspaceProps } from 'aws-cdk-lib/aws-grafana';\nimport { IRole } from 'aws-cdk-lib/aws-iam';\nimport { Construct } from 'constructs';\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 * Properties for creating an Amazon Managed Grafana workspace.\n */\nexport interface WorkspaceProps {\n  /**\n   * Type of account access for the workspace.\n   * Required field.\n   */\n  readonly accountAccessType: AccountAccessType;\n\n  /**\n   * Authentication providers to enable for the workspace.\n   * Required field.\n   */\n  readonly authenticationProviders: AuthenticationProviders[];\n\n  /**\n   * Client token for idempotent workspace creation.\n   * Must be 1-64 characters long and contain only printable ASCII characters.\n   */\n  readonly clientToken?: string;\n\n  /**\n   * List of data sources to enable for the workspace.\n   */\n  readonly dataSources?: string[];\n\n  /**\n   * Description of the workspace.\n   * Maximum length of 2048 characters.\n   */\n  readonly description?: string;\n\n  /**\n   * Grafana version for the workspace.\n   * Must be 1-255 characters long.\n   */\n  readonly grafanaVersion?: string;\n\n  /**\n   * Name of the workspace.\n   * Must be 1-255 characters long and contain only alphanumeric characters, hyphens, dots, underscores, and tildes.\n   */\n  readonly name?: string;\n\n  /**\n   * Network access control configuration for the workspace.\n   */\n  readonly networkAccessControl?: NetworkAccessControl;\n\n  /**\n   * Notification destinations to enable for the workspace.\n   */\n  readonly notificationDestinations?: NotificationDestinations[];\n\n  /**\n   * List of organizational units to include in the workspace.\n   */\n  readonly organizationalUnits?: string[];\n\n  /**\n   * Name of the IAM role to use for the organization.\n   * Maximum length of 2048 characters.\n   */\n  readonly organizationRoleName?: string;\n\n  /**\n   * Permission type for the workspace.\n   * Required field.\n   */\n  readonly permissionType: PermissionTypes;\n\n  /**\n   * Whether to enable the Grafana plugin admin page.\n   * Default: false\n   */\n  readonly pluginAdminEnabled?: boolean;\n\n  /**\n   * IAM role to use for the workspace.\n   */\n  readonly role?: IRole;\n\n  /**\n   * SAML configuration for the workspace.\n   */\n  readonly samlConfiguration?: SamlConfiguration;\n\n  /**\n   * Name of the CloudFormation stack set to use.\n   */\n  readonly stackSetName?: string;\n\n  /**\n   * VPC configuration for the workspace.\n   */\n  readonly vpcConfiguration?: VpcConfiguration;\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 Grafana workspace.\n *\n * This class provides a high-level abstraction for creating and managing\n * Amazon Managed Grafana workspaces using AWS CDK.\n */\nexport class Workspace extends Construct {\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   */\n  private static validateClientToken(token: unknown): string[] {\n    const errors: string[] = [];\n\n    if (token === undefined) {\n      return errors; // Optional property can be undefined\n    }\n\n    if (typeof token !== 'string') {\n      errors.push('clientToken must be a string');\n      return errors; // No need to check further if not a string\n    }\n\n    const regex = /^[!-~]{1,64}$/;\n    if (!regex.test(token)) {\n      if (token.length < 1 || token.length > 64) {\n        errors.push('clientToken must be between 1 and 64 characters long');\n      }\n\n      if (!/^[!-~]*$/.test(token)) {\n        errors.push('clientToken must contain only printable ASCII characters');\n      }\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   */\n  private static validateDescription(description: unknown): string[] {\n    const errors: string[] = [];\n\n    if (description === undefined) {\n      return errors; // Optional property can be undefined\n    }\n\n    if (typeof description !== 'string') {\n      errors.push('description must be a string');\n      return errors; // No need to check further if not a string\n    }\n\n    if (description.length > 2048) {\n      errors.push('description cannot exceed 2048 characters');\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   */\n  private static validateGrafanaVersion(version: unknown): string[] {\n    const errors: string[] = [];\n\n    if (version === undefined) {\n      return errors; // Optional property can be undefined\n    }\n\n    if (typeof version !== 'string') {\n      errors.push('grafanaVersion must be a string');\n      return errors; // No need to check further if not a string\n    }\n\n    if (version.length < 1) {\n      errors.push('grafanaVersion cannot be empty');\n    }\n\n    if (version.length > 255) {\n      errors.push('grafanaVersion cannot exceed 255 characters');\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   */\n  private static validateName(name: unknown): string[] {\n    const errors: string[] = [];\n\n    if (name === undefined) {\n      return errors; // Optional property can be undefined\n    }\n\n    if (typeof name !== 'string') {\n      errors.push('name must be a string');\n      return errors; // No need to check further if not a string\n    }\n\n    const regex = /^[a-zA-Z0-9\\-._~]{1,255}$/;\n    if (!regex.test(name)) {\n      if (name.length < 1 || name.length > 255) {\n        errors.push('name must be between 1 and 255 characters long');\n      }\n\n      if (!/^[a-zA-Z0-9\\-._~]*$/.test(name)) {\n        errors.push(\n          'name can only contain alphanumeric characters, hyphens, dots, underscores, and tildes',\n        );\n      }\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   */\n  private static validateNetworkAccessControl(nac: unknown): string[] {\n    const errors: string[] = [];\n\n    if (nac === undefined) {\n      return errors; // Optional property can be undefined\n    }\n\n    if (!nac || typeof nac !== 'object') {\n      errors.push('networkAccessControl 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 if (networkAccessControl.prefixLists.length > 5) {\n        errors.push('prefixLists can have at most 5 items');\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 if (networkAccessControl.vpcEndpoints.length > 5) {\n        errors.push('vpcEndpoints can have at most 5 items');\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   */\n  private static validateOrganizationRoleName(roleName: unknown): string[] {\n    const errors: string[] = [];\n\n    if (roleName === undefined) {\n      return errors; // Optional property can be undefined\n    }\n\n    if (typeof roleName !== 'string') {\n      errors.push('organizationRoleName must be a string');\n      return errors; // No need to check further if not a string\n    }\n\n    if (roleName.length < 1) {\n      errors.push('organizationRoleName cannot be empty');\n    }\n\n    if (roleName.length > 2048) {\n      errors.push('organizationRoleName cannot exceed 2048 characters');\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   */\n  private static validateSamlAssertionAttributes(obj: unknown): string[] {\n    const errors: string[] = [];\n\n    if (!obj || typeof obj !== 'object') {\n      return ['Input is not 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 if (value.length < 1) {\n        errors.push(`Property '${key}' cannot be empty`);\n      } else if (value.length > 256) {\n        errors.push(\n          `Property '${key}' exceeds maximum length of 256 characters`,\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   */\n  private static validateSamlIdpMetadata(obj: unknown): string[] {\n    const errors: string[] = [];\n\n    if (!obj || typeof obj !== 'object') {\n      return ['Input is not 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 if (metadata.url.length < 1) {\n        errors.push(\"Property 'url' cannot be empty\");\n      } else if (metadata.url.length > 2048) {\n        errors.push(\"Property 'url' exceeds maximum length of 2048 characters\");\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   */\n  private static validateSamlConfiguration(config: unknown): string[] {\n    const errors: string[] = [];\n\n    if (config === undefined) {\n      return errors; // Optional property can be undefined\n    }\n\n    if (!config || typeof config !== 'object') {\n      errors.push('samlConfiguration 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 = Workspace.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 = Workspace.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        if (samlConfig.allowedOrganizations.length < 1) {\n          errors.push('allowedOrganizations must have at least 1 element');\n        }\n        if (samlConfig.allowedOrganizations.length > 256) {\n          errors.push(\n            'allowedOrganizations cannot have more than 256 elements',\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 if (samlConfig.loginValidityDuration <= 0) {\n        errors.push('loginValidityDuration must be positive');\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        }\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        }\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   */\n  private static validateVpcConfiguration(config: unknown): string[] {\n    const errors: string[] = [];\n\n    if (config === undefined) {\n      return errors; // Optional property can be undefined\n    }\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      if (vpcConfig.securityGroups.length < 1) {\n        errors.push('securityGroups must have at least 1 item');\n      }\n      if (vpcConfig.securityGroups.length > 5) {\n        errors.push('securityGroups cannot have more than 5 items');\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      if (vpcConfig.subnets.length < 2) {\n        errors.push('subnets must have at least 2 items');\n      }\n      if (vpcConfig.subnets.length > 6) {\n        errors.push('subnets cannot have more than 6 items');\n      }\n    }\n\n    return errors;\n  }\n\n  /**\n   * Validates all workspace properties.\n   *\n   * @param props - The workspace properties to validate\n   * @returns An array of error messages if validation fails, or an empty array if valid\n   *\n   * This method aggregates validation results from all individual property validators.\n   * It throws an error if props is not an object.\n   */\n  private static validateProps(props: unknown): string[] {\n    const errors: string[] = [];\n\n    if (!props || typeof props !== 'object') {\n      throw new Error('Props is not an object');\n    }\n    const workspaceProps = props as WorkspaceProps;\n\n    if (workspaceProps.clientToken !== undefined) {\n      const clientTokenErrors = Workspace.validateClientToken(\n        workspaceProps.clientToken,\n      );\n      if (clientTokenErrors.length > 0) {\n        errors.push(...clientTokenErrors.map((err) => `clientToken: ${err}`));\n      }\n    }\n\n    if (workspaceProps.description !== undefined) {\n      const descriptionErrors = Workspace.validateDescription(\n        workspaceProps.description,\n      );\n      if (descriptionErrors.length > 0) {\n        errors.push(...descriptionErrors.map((err) => `description: ${err}`));\n      }\n    }\n\n    if (workspaceProps.grafanaVersion !== undefined) {\n      const grafanaVersionErrors = Workspace.validateGrafanaVersion(\n        workspaceProps.grafanaVersion,\n      );\n      if (grafanaVersionErrors.length > 0) {\n        errors.push(\n          ...grafanaVersionErrors.map((err) => `grafanaVersion: ${err}`),\n        );\n      }\n    }\n\n    if (workspaceProps.name !== undefined) {\n      const nameErrors = Workspace.validateName(workspaceProps.name);\n      if (nameErrors.length > 0) {\n        errors.push(...nameErrors.map((err) => `name: ${err}`));\n      }\n    }\n\n    if (workspaceProps.networkAccessControl !== undefined) {\n      const networkAccessControlErrors = Workspace.validateNetworkAccessControl(\n        workspaceProps.networkAccessControl,\n      );\n      if (networkAccessControlErrors.length > 0) {\n        errors.push(\n          ...networkAccessControlErrors.map(\n            (err) => `networkAccessControl: ${err}`,\n          ),\n        );\n      }\n    }\n\n    if (workspaceProps.organizationRoleName !== undefined) {\n      const organizationRoleNameErrors = Workspace.validateOrganizationRoleName(\n        workspaceProps.organizationRoleName,\n      );\n      if (organizationRoleNameErrors.length > 0) {\n        errors.push(\n          ...organizationRoleNameErrors.map(\n            (err) => `organizationRoleName: ${err}`,\n          ),\n        );\n      }\n    }\n\n    if (workspaceProps.samlConfiguration !== undefined) {\n      const samlConfigurationErrors = Workspace.validateSamlConfiguration(\n        workspaceProps.samlConfiguration,\n      );\n      if (samlConfigurationErrors.length > 0) {\n        errors.push(\n          ...samlConfigurationErrors.map((err) => `samlConfiguration: ${err}`),\n        );\n      }\n    }\n\n    if (workspaceProps.vpcConfiguration !== undefined) {\n      const vpcConfigurationErrors = Workspace.validateVpcConfiguration(\n        workspaceProps.vpcConfiguration,\n      );\n      if (vpcConfigurationErrors.length > 0) {\n        errors.push(\n          ...vpcConfigurationErrors.map((err) => `vpcConfiguration: ${err}`),\n        );\n      }\n    }\n\n    return errors;\n  }\n\n  /**\n   * The type of account access for the workspace.\n   */\n  public readonly accountAccessType: AccountAccessType;\n\n  /**\n   * Authentication providers enabled for the workspace.\n   */\n  public readonly authenticationProviders: AuthenticationProviders[];\n\n  /**\n   * Client token used for idempotent workspace creation.\n   */\n  public readonly clientToken?: string;\n\n  /**\n   * Data sources enabled for the workspace.\n   */\n  public readonly dataSources?: string[];\n\n  /**\n   * Description of the workspace.\n   */\n  public readonly description?: string;\n\n  /**\n   * Name of the workspace.\n   */\n  public readonly name?: string;\n\n  /**\n   * Network access control configuration for the workspace.\n   */\n  public readonly networkAccessControl?: NetworkAccessControl;\n\n  /**\n   * Notification destinations enabled for the workspace.\n   */\n  public readonly notificationDestinations?: NotificationDestinations[];\n\n  /**\n   * Organizational units included in the workspace.\n   */\n  public readonly organizationalUnits?: string[];\n\n  /**\n   * Name of the IAM role used for the organization.\n   */\n  public readonly organizationRoleName?: string;\n\n  /**\n   * Permission type for the workspace.\n   */\n  public readonly permissionType: PermissionTypes;\n\n  /**\n   * Whether the Grafana plugin admin page is enabled.\n   */\n  public readonly pluginAdminEnabled?: boolean;\n\n  /**\n   * IAM role used for the workspace.\n   */\n  public readonly role?: IRole;\n\n  /**\n   * SAML configuration for the workspace.\n   */\n  public readonly samlConfiguration?: SamlConfiguration;\n\n  /**\n   * Name of the CloudFormation stack set used.\n   */\n  public readonly stackSetName?: string;\n\n  /**\n   * VPC configuration for the workspace.\n   */\n  public readonly vpcConfiguration?: VpcConfiguration;\n\n  /**\n   * The underlying CloudFormation resource.\n   */\n  private readonly workspace: CfnWorkspace;\n\n  /**\n   * Timestamp when the workspace was created.\n   */\n  public readonly creationTimestamp: string;\n\n  /**\n   * Endpoint URL for the Grafana workspace.\n   */\n  public readonly endpoint: string;\n\n  /**\n   * Grafana version running in the workspace.\n   */\n  public readonly grafanaVersion: string;\n\n  /**\n   * Unique identifier for the workspace.\n   */\n  public readonly id: string;\n\n  /**\n   * Timestamp when the workspace was last modified.\n   */\n  public readonly modificationTimestamp: string;\n\n  /**\n   * Status of SAML configuration for the workspace.\n   */\n  public readonly samlConfigurationStatus: SamlConfigurationStatuses;\n\n  /**\n   * SSO client ID for the workspace.\n   */\n  public readonly ssoClientId: string;\n\n  /**\n   * Current status of the workspace.\n   */\n  public readonly status: Status;\n\n  /**\n   * Creates a new Amazon Managed Grafana workspace.\n   *\n   * @param scope - The scope in which to define this construct\n   * @param id - The scoped construct ID\n   * @param props - Configuration properties for the workspace\n   *\n   * @throws Error if any of the provided properties fail validation\n   */\n  constructor(scope: Construct, id: string, props: WorkspaceProps) {\n    super(scope, id);\n\n    const errors = Workspace.validateProps(props);\n    if (errors.length > 0) {\n      throw new Error(`Invalid props:\\n${errors.join('\\n')}`);\n    }\n\n    if (\n      props.accountAccessType === AccountAccessType.CURRENT_ACCOUNT &&\n      !props.role\n    ) {\n      throw new Error(\n        'Role must be provided when accountAccessType is CURRENT_ACCOUNT',\n      );\n    }\n\n    this.accountAccessType = props.accountAccessType;\n    this.authenticationProviders = props.authenticationProviders;\n    this.clientToken = props.clientToken;\n    this.dataSources = props.dataSources;\n    this.description = props.description;\n    this.networkAccessControl = props.networkAccessControl;\n    this.notificationDestinations = props.notificationDestinations;\n    this.organizationalUnits = props.organizationalUnits;\n    this.organizationRoleName = props.organizationRoleName;\n    this.permissionType = props.permissionType;\n    this.pluginAdminEnabled = props.pluginAdminEnabled;\n    this.name = props.name;\n    this.role = props.role;\n    this.samlConfiguration = props.samlConfiguration;\n    this.stackSetName = props.stackSetName;\n    this.vpcConfiguration = props.vpcConfiguration;\n\n    let cfnWorkspaceProps: CfnWorkspaceProps = {\n      accountAccessType: props.accountAccessType,\n      authenticationProviders: props.authenticationProviders,\n      clientToken: props.clientToken,\n      dataSources: props.dataSources,\n      description: props.description,\n      grafanaVersion: props.grafanaVersion,\n      name: props.name,\n      notificationDestinations: props.notificationDestinations,\n      organizationalUnits: props.organizationalUnits,\n      organizationRoleName: props.organizationRoleName,\n      permissionType: props.permissionType,\n      pluginAdminEnabled: props.pluginAdminEnabled,\n      roleArn: props.role?.roleArn,\n      samlConfiguration: props.samlConfiguration,\n      stackSetName: props.stackSetName,\n      vpcConfiguration: props.vpcConfiguration\n        ? {\n          securityGroupIds: props.vpcConfiguration.securityGroups.map(\n            (sg) => sg.securityGroupId,\n          ),\n          subnetIds: props.vpcConfiguration.subnets.map(\n            (subnet) => subnet.subnetId,\n          ),\n        }\n        : undefined,\n    };\n\n    this.workspace = new CfnWorkspace(this, 'Resource', cfnWorkspaceProps);\n    this.creationTimestamp = this.workspace.attrCreationTimestamp;\n    this.endpoint = this.workspace.attrEndpoint;\n    this.grafanaVersion = this.workspace.attrGrafanaVersion;\n    this.id = this.workspace.attrId;\n    this.modificationTimestamp = this.workspace.attrModificationTimestamp;\n    this.samlConfigurationStatus = this.workspace\n      .attrSamlConfigurationStatus as SamlConfigurationStatuses;\n    this.ssoClientId = this.workspace.attrSsoClientId;\n    this.status = this.workspace.attrStatus as Status;\n  }\n}\n"]}