@spottoai/types-package 1.0.2-dev1138.12 → 1.0.2-dev1138.14

package/dist/esm/aws/portalRelationshipResourceNodeValidation.js

@@ -1,368 +0,0 @@
-import { AWS_PORTAL_RELATIONSHIP_DISCOVERY_FAMILIES } from './portalRelationshipPublicArtifacts.js';
-import { validateResourceBillingEvidence } from './portalPublicArtifactNestedEvidenceValidation.js';
-import { asRecord, assertExactKeys, assertValue, finiteNumber, requiredBoolean, requiredEnum, requiredString, stringArray, } from './portalPublicArtifactValidationCommon.js';
-import { assertAccount, assertRequiredKeys } from './pluginPublicArtifactValidationHelpers.js';
-const RESOURCE_COMMON_KEYS = ['provider', 'accountId', 'family', 'resourceRegion', 'stableKey', 'resourceType', 'tags', 'billing'];
-const RESOURCE_KEYS = {
-    'ec2-instance': ['instanceId', 'instanceArn', 'name', 'state', 'instanceType', 'availabilityZone', 'subnetId', 'vpcId'],
-    'ebs-volume': ['volumeId', 'volumeArn', 'state', 'availabilityZone', 'volumeType', 'sizeGiB', 'encrypted', 'snapshotId', 'attachments'],
-    vpc: [
-        'vpcId',
-        'vpcArn',
-        'state',
-        'cidrBlock',
-        'dhcpOptionsId',
-        'instanceTenancy',
-        'isDefault',
-        'ownerId',
-        'cidrBlockAssociations',
-        'ipv6CidrBlockAssociations',
-    ],
-    subnet: [
-        'subnetArn',
-        'subnetId',
-        'vpcId',
-        'availabilityZone',
-        'availabilityZoneId',
-        'state',
-        'cidrBlock',
-        'availableIpAddressCount',
-        'defaultForAz',
-        'mapPublicIpOnLaunch',
-        'assignIpv6AddressOnCreation',
-        'ipv6Native',
-        'ownerId',
-        'customerOwnedIpv4Pool',
-        'mapCustomerOwnedIpOnLaunch',
-        'outpostArn',
-        'enableDns64',
-        'enableLniAtDeviceIndex',
-        'privateDnsHostnameType',
-        'privateDnsEnableResourceNameDnsARecord',
-        'privateDnsEnableResourceNameDnsAAAARecord',
-        'ipv6CidrBlockAssociations',
-    ],
-    'route-table': ['routeTableArn', 'routeTableId', 'vpcId', 'ownerId', 'hasMainAssociation', 'associations'],
-    'internet-gateway': ['internetGatewayArn', 'internetGatewayId', 'ownerId', 'attachments', 'attachedVpcIds'],
-    'virtual-private-gateway': [
-        'virtualPrivateGatewayArn',
-        'virtualPrivateGatewayId',
-        'amazonSideAsn',
-        'availabilityZone',
-        'state',
-        'type',
-        'attachments',
-        'attachedVpcIds',
-    ],
-    'network-interface': [
-        'networkInterfaceId',
-        'ownerId',
-        'subnetId',
-        'vpcId',
-        'availabilityZone',
-        'status',
-        'interfaceType',
-        'requesterManaged',
-        'requesterId',
-        'privateIpAddress',
-        'attachmentInstanceId',
-    ],
-    'nat-gateway': [
-        'natGatewayId',
-        'natGatewayArn',
-        'subnetId',
-        'vpcId',
-        'availabilityZone',
-        'state',
-        'connectivityType',
-        'failureCode',
-        'failureMessage',
-        'createTime',
-        'deleteTime',
-        'addresses',
-    ],
-    'security-group': ['groupId', 'securityGroupArn', 'groupName', 'description', 'vpcId', 'ownerId'],
-    'rds-db-cluster': [
-        'dbClusterResourceId',
-        'dbClusterIdentifier',
-        'dbClusterArn',
-        'engine',
-        'engineVersion',
-        'engineMode',
-        'status',
-        'serverlessV2MinCapacityAcu',
-        'serverlessV2MaxCapacityAcu',
-        'serverlessV2SecondsUntilAutoPause',
-        'serverlessV2PlatformVersion',
-        'globalClusterIdentifier',
-        'clusterScalabilityType',
-        'limitlessDatabaseStatus',
-        'endpointAddress',
-        'readerEndpointAddress',
-        'hostedZoneId',
-        'endpointPort',
-        'availabilityZones',
-        'storageEncrypted',
-        'kmsKeyId',
-        'deletionProtection',
-        'copyTagsToSnapshot',
-        'dbProxyNames',
-        'dbClusterMemberIdentifiers',
-        'dbClusterMembers',
-    ],
-    'rds-db-instance': [
-        'dbInstanceIdentifier',
-        'dbiResourceId',
-        'dbInstanceArn',
-        'engine',
-        'engineVersion',
-        'dbInstanceClass',
-        'status',
-        'availabilityZone',
-        'vpcId',
-        'dbSubnetGroupName',
-        'dbClusterIdentifier',
-    ],
-    'load-balancer-v2': ['loadBalancerArn', 'loadBalancerName', 'loadBalancerType', 'scheme', 'state', 'vpcId', 'subnetIds', 'availabilityZoneNames'],
-    'classic-load-balancer': ['loadBalancerName', 'scheme', 'vpcId', 'subnetIds', 'availabilityZoneNames', 'securityGroupIds', 'instanceIds'],
-    'elasticache-cache-cluster': [
-        'cacheClusterId',
-        'cacheClusterArn',
-        'engine',
-        'engineVersion',
-        'status',
-        'cacheNodeType',
-        'preferredAvailabilityZone',
-        'cacheSubnetGroupName',
-        'replicationGroupId',
-        'replicationGroupGlobalReplicationGroupId',
-        'kmsKeyId',
-    ],
-    'elasticache-serverless-cache': ['serverlessCacheName', 'serverlessCacheArn', 'engine', 'majorEngineVersion', 'status', 'subnetIds', 'kmsKeyId'],
-    'efs-file-system': ['fileSystemId', 'fileSystemArn', 'name', 'state', 'availabilityZoneName', 'encrypted', 'kmsKeyId'],
-};
-const REQUIRED_RESOURCE_KEYS = {
-    'ec2-instance': ['instanceId', 'instanceArn'],
-    'ebs-volume': ['volumeId', 'volumeArn', 'attachments'],
-    vpc: ['vpcId', 'vpcArn', 'cidrBlockAssociations', 'ipv6CidrBlockAssociations'],
-    subnet: ['subnetArn', 'subnetId', 'ipv6CidrBlockAssociations'],
-    'route-table': ['routeTableArn', 'routeTableId', 'hasMainAssociation', 'associations'],
-    'internet-gateway': ['internetGatewayArn', 'internetGatewayId', 'attachments', 'attachedVpcIds'],
-    'virtual-private-gateway': ['virtualPrivateGatewayArn', 'virtualPrivateGatewayId', 'attachments', 'attachedVpcIds'],
-    'network-interface': ['networkInterfaceId'],
-    'nat-gateway': ['natGatewayId', 'natGatewayArn', 'addresses'],
-    'security-group': ['groupId', 'groupName'],
-    'rds-db-cluster': [
-        'dbClusterResourceId',
-        'dbClusterIdentifier',
-        'dbClusterArn',
-        'availabilityZones',
-        'dbProxyNames',
-        'dbClusterMemberIdentifiers',
-        'dbClusterMembers',
-    ],
-    'rds-db-instance': ['dbInstanceIdentifier', 'dbiResourceId', 'dbInstanceArn'],
-    'load-balancer-v2': ['loadBalancerArn', 'loadBalancerName', 'subnetIds', 'availabilityZoneNames'],
-    'classic-load-balancer': ['loadBalancerName', 'subnetIds', 'availabilityZoneNames', 'securityGroupIds', 'instanceIds'],
-    'elasticache-cache-cluster': ['cacheClusterId', 'cacheClusterArn'],
-    'elasticache-serverless-cache': ['serverlessCacheName', 'serverlessCacheArn', 'subnetIds'],
-    'efs-file-system': ['fileSystemId', 'fileSystemArn'],
-};
-const STRING_FIELDS = new Set([
-    'stableKey',
-    'resourceType',
-    ...Object.values(RESOURCE_KEYS)
-        .flat()
-        .filter(field => ![
-        'attachments',
-        'addresses',
-        'associations',
-        'attachedVpcIds',
-        'availabilityZoneNames',
-        'availabilityZones',
-        'cidrBlockAssociations',
-        'dbClusterMemberIdentifiers',
-        'dbClusterMembers',
-        'dbProxyNames',
-        'instanceIds',
-        'ipv6CidrBlockAssociations',
-        'securityGroupIds',
-        'subnetIds',
-        'availableIpAddressCount',
-        'amazonSideAsn',
-        'enableLniAtDeviceIndex',
-        'endpointPort',
-        'serverlessV2MaxCapacityAcu',
-        'serverlessV2MinCapacityAcu',
-        'serverlessV2SecondsUntilAutoPause',
-        'sizeGiB',
-        'assignIpv6AddressOnCreation',
-        'copyTagsToSnapshot',
-        'defaultForAz',
-        'deletionProtection',
-        'enableDns64',
-        'encrypted',
-        'hasMainAssociation',
-        'ipv6Native',
-        'isDefault',
-        'mapCustomerOwnedIpOnLaunch',
-        'mapPublicIpOnLaunch',
-        'privateDnsEnableResourceNameDnsARecord',
-        'privateDnsEnableResourceNameDnsAAAARecord',
-        'requesterManaged',
-        'storageEncrypted',
-    ].includes(field)),
-]);
-const NUMBER_FIELDS = new Set([
-    'amazonSideAsn',
-    'availableIpAddressCount',
-    'enableLniAtDeviceIndex',
-    'endpointPort',
-    'serverlessV2MaxCapacityAcu',
-    'serverlessV2MinCapacityAcu',
-    'serverlessV2SecondsUntilAutoPause',
-    'sizeGiB',
-]);
-const BOOLEAN_FIELDS = new Set([
-    'assignIpv6AddressOnCreation',
-    'copyTagsToSnapshot',
-    'defaultForAz',
-    'deletionProtection',
-    'enableDns64',
-    'encrypted',
-    'hasMainAssociation',
-    'ipv6Native',
-    'isDefault',
-    'mapCustomerOwnedIpOnLaunch',
-    'mapPublicIpOnLaunch',
-    'privateDnsEnableResourceNameDnsARecord',
-    'privateDnsEnableResourceNameDnsAAAARecord',
-    'requesterManaged',
-    'storageEncrypted',
-]);
-const STRING_ARRAY_FIELDS = new Set([
-    'attachedVpcIds',
-    'availabilityZoneNames',
-    'availabilityZones',
-    'dbClusterMemberIdentifiers',
-    'dbProxyNames',
-    'instanceIds',
-    'securityGroupIds',
-    'subnetIds',
-]);
-export function validateAwsPortalRelationshipResourceNode(data, accountId, regions, field) {
-    assertValue(data.provider, 'aws', `${field}.provider`);
-    assertAccount(data.accountId, accountId, `${field}.accountId`);
-    const resourceRegion = requiredString(data.resourceRegion, `${field}.resourceRegion`);
-    if (!regions.has(resourceRegion))
-        throw new Error(`${field}.resourceRegion is outside artifact scope.`);
-    const family = requiredEnum(data.family, AWS_PORTAL_RELATIONSHIP_DISCOVERY_FAMILIES, `${field}.family`);
-    assertExactKeys(data, [...RESOURCE_COMMON_KEYS, ...RESOURCE_KEYS[family]], field);
-    assertRequiredKeys(data, ['provider', 'accountId', 'family', 'resourceRegion', 'stableKey', 'resourceType', ...REQUIRED_RESOURCE_KEYS[family]], field);
-    for (const key of Object.keys(data)) {
-        if (STRING_FIELDS.has(key) && data[key] !== undefined)
-            requiredString(data[key], `${field}.${key}`);
-        if (NUMBER_FIELDS.has(key) && data[key] !== undefined)
-            finiteNumber(data[key], `${field}.${key}`);
-        if (BOOLEAN_FIELDS.has(key) && data[key] !== undefined)
-            requiredBoolean(data[key], `${field}.${key}`);
-        if (STRING_ARRAY_FIELDS.has(key) && data[key] !== undefined)
-            stringArray(data[key], `${field}.${key}`);
-    }
-    if (data.tags !== undefined)
-        validateTags(data.tags, `${field}.tags`);
-    if (data.billing !== undefined)
-        validateResourceBillingEvidence(data.billing, `${field}.billing`);
-    validateNativeScopeIdentity(data, accountId, resourceRegion, field);
-    validateNestedResourceArrays(data, family, field);
-}
-function validateNativeScopeIdentity(data, accountId, resourceRegion, field) {
-    if (data.ownerId !== undefined)
-        assertAccount(data.ownerId, accountId, `${field}.ownerId`);
-    Object.entries(data).forEach(([key, value]) => {
-        if (typeof value !== 'string')
-            return;
-        if (key.endsWith('Arn') || key === 'stableKey' || key === 'kmsKeyId') {
-            if (value.startsWith('arn:'))
-                validateScopedArn(value, accountId, resourceRegion, `${field}.${key}`);
-        }
-        if (['availabilityZone', 'availabilityZoneName', 'preferredAvailabilityZone'].includes(key))
-            validateAvailabilityZone(value, resourceRegion, `${field}.${key}`);
-    });
-    for (const key of ['availabilityZones', 'availabilityZoneNames']) {
-        if (!Array.isArray(data[key]))
-            continue;
-        data[key].forEach((value, index) => {
-            if (typeof value === 'string')
-                validateAvailabilityZone(value, resourceRegion, `${field}.${key}[${index}]`);
-        });
-    }
-}
-function validateScopedArn(value, accountId, resourceRegion, field) {
-    const match = /^arn:(aws(?:-[a-z0-9-]+)?):[^:]+:([^:]*):([^:]*):.+$/.exec(value);
-    if (!match)
-        throw new Error(`${field} must be a canonical AWS ARN.`);
-    const [, , arnRegion, arnAccountId] = match;
-    if (arnRegion !== resourceRegion)
-        throw new Error(`${field} ARN Region must match its resource node.`);
-    if (arnAccountId !== accountId)
-        throw new Error(`${field} ARN account must match its resource node.`);
-}
-function validateAvailabilityZone(value, resourceRegion, field) {
-    if (resourceRegion === 'global' || value === resourceRegion || !value.startsWith(resourceRegion))
-        throw new Error(`${field} must belong to its resource Region.`);
-}
-function validateTags(value, field) {
-    const tags = asRecord(value, field);
-    Object.entries(tags).forEach(([key, tagValue]) => {
-        requiredString(key, `${field} key`);
-        requiredString(tagValue, `${field}.${key}`);
-    });
-}
-function validateNestedResourceArrays(data, family, field) {
-    if (family === 'vpc') {
-        validateObjectArray(data.cidrBlockAssociations, ['associationId', 'cidrBlock', 'state'], ['cidrBlock'], `${field}.cidrBlockAssociations`);
-        validateObjectArray(data.ipv6CidrBlockAssociations, ['associationId', 'ipv6CidrBlock', 'state'], ['ipv6CidrBlock'], `${field}.ipv6CidrBlockAssociations`);
-    }
-    else if (family === 'subnet') {
-        validateObjectArray(data.ipv6CidrBlockAssociations, ['associationId', 'ipv6CidrBlock', 'state'], ['ipv6CidrBlock'], `${field}.ipv6CidrBlockAssociations`);
-    }
-    else if (family === 'route-table') {
-        validateObjectArray(data.associations, ['associationId', 'subnetId', 'gatewayId', 'main', 'associationState', 'associationStateMessage'], [], `${field}.associations`);
-    }
-    else if (family === 'internet-gateway' || family === 'virtual-private-gateway') {
-        validateObjectArray(data.attachments, ['vpcId', 'state'], [], `${field}.attachments`);
-    }
-    else if (family === 'ebs-volume') {
-        validateObjectArray(data.attachments, ['instanceId', 'device', 'state', 'attachTime', 'deleteOnTermination'], [], `${field}.attachments`);
-    }
-    else if (family === 'nat-gateway') {
-        validateObjectArray(data.addresses, ['allocationId', 'associationId', 'isPrimary', 'networkInterfaceId', 'privateIp', 'publicIp', 'status'], [], `${field}.addresses`);
-    }
-    else if (family === 'rds-db-cluster') {
-        validateObjectArray(data.dbClusterMembers, ['dbInstanceIdentifier', 'isClusterWriter', 'promotionTier'], ['dbInstanceIdentifier'], `${field}.dbClusterMembers`);
-    }
-}
-function validateObjectArray(value, keys, required, field) {
-    asArray(value, field).forEach((entry, index) => {
-        const itemField = `${field}[${index}]`;
-        const item = asRecord(entry, itemField);
-        assertExactKeys(item, keys, itemField);
-        assertRequiredKeys(item, required, itemField);
-        Object.entries(item).forEach(([key, itemValue]) => {
-            if (itemValue === undefined)
-                return;
-            if (['main', 'deleteOnTermination', 'isPrimary', 'isClusterWriter'].includes(key))
-                requiredBoolean(itemValue, `${itemField}.${key}`);
-            else if (key === 'promotionTier')
-                finiteNumber(itemValue, `${itemField}.${key}`);
-            else
-                requiredString(itemValue, `${itemField}.${key}`);
-        });
-    });
-}
-function asArray(value, field) {
-    if (!Array.isArray(value))
-        throw new Error(`${field} must be an array.`);
-    return value;
-}

package/dist/esm/scheduler/bastionScheduleProfile.js

@@ -1,206 +0,0 @@
-const MAX_IDENTIFIER_LENGTH = 2048;
-const MAX_ETAG_LENGTH = 4096;
-const MAX_LOCATION_LENGTH = 128;
-const MAX_IP_CONFIGURATION_NAME_LENGTH = 80;
-const MAX_TAG_COUNT = 50;
-const MAX_TAG_NAME_LENGTH = 512;
-const MAX_TAG_VALUE_LENGTH = 256;
-function isPlainRecord(value) {
-    if (typeof value !== 'object' || value === null || Array.isArray(value))
-        return false;
-    const prototype = Reflect.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
-function hasOnlyFields(value, fields) {
-    const allowed = new Set(fields);
-    return Object.keys(value).every(field => allowed.has(field));
-}
-function readString(value, maximumLength) {
-    if (typeof value !== 'string' || value.trim().length === 0 || value.length > maximumLength)
-        return undefined;
-    return value.trim();
-}
-function normalizeResourceId(value) {
-    const resourceId = readString(value, MAX_IDENTIFIER_LENGTH);
-    if (!resourceId || resourceId.includes('\\') || resourceId.includes('//') || resourceId.endsWith('/'))
-        return undefined;
-    return resourceId.toLowerCase();
-}
-function readBastionSubscriptionId(resourceId) {
-    return /^\/subscriptions\/([a-z0-9-]+)\/resourcegroups\/[a-z0-9._()-]+\/providers\/microsoft\.network\/bastionhosts\/[a-z0-9._()-]+$/.exec(resourceId)?.[1];
-}
-function readBoolean(value) {
-    return value === undefined ? false : typeof value === 'boolean' ? value : undefined;
-}
-function readTags(value) {
-    if (value === undefined)
-        return {};
-    if (!isPlainRecord(value) || Object.keys(value).length > MAX_TAG_COUNT)
-        return undefined;
-    const entries = [];
-    for (const key of Object.keys(value).sort()) {
-        const tagValue = value[key];
-        if (key.length === 0 || key.length > MAX_TAG_NAME_LENGTH || typeof tagValue !== 'string' || tagValue.length > MAX_TAG_VALUE_LENGTH) {
-            return undefined;
-        }
-        entries.push([key, tagValue]);
-    }
-    return Object.fromEntries(entries);
-}
-function readZones(value) {
-    if (value === undefined)
-        return undefined;
-    if (!Array.isArray(value) ||
-        value.length < 1 ||
-        value.length > 3 ||
-        !value.every(zone => typeof zone === 'string' && /^[1-3]$/.test(zone)) ||
-        new Set(value).size !== value.length) {
-        return false;
-    }
-    return [...value].sort();
-}
-function readSku(value) {
-    if (!isPlainRecord(value) || !hasOnlyFields(value, ['name']))
-        return undefined;
-    const name = value['name'];
-    return name === 'Basic' || name === 'Standard' || name === 'Premium' ? name : undefined;
-}
-/** Normalizes an eligible public dedicated Azure Bastion profile for schedule readiness and recovery. */
-export function readSupportedBastionScheduleProfileV1(value, expectedResourceId) {
-    try {
-        if (!isPlainRecord(value) ||
-            !hasOnlyFields(value, ['name', 'id', 'etag', 'type', 'location', 'tags', 'sku', 'properties', 'systemData', 'zones'])) {
-            return undefined;
-        }
-        const normalizedExpectedResourceId = normalizeResourceId(expectedResourceId);
-        const normalizedSourceResourceId = normalizeResourceId(value['id']);
-        const bastionSubscriptionId = normalizedSourceResourceId ? readBastionSubscriptionId(normalizedSourceResourceId) : undefined;
-        const resourceType = readString(value['type'], MAX_IDENTIFIER_LENGTH)?.toLowerCase();
-        const sourceEtag = readString(value['etag'], MAX_ETAG_LENGTH);
-        const location = readString(value['location'], MAX_LOCATION_LENGTH)?.toLowerCase();
-        const tags = readTags(value['tags']);
-        const skuName = readSku(value['sku']);
-        const zones = readZones(value['zones']);
-        if (!normalizedExpectedResourceId ||
-            normalizedSourceResourceId !== normalizedExpectedResourceId ||
-            !bastionSubscriptionId ||
-            resourceType !== 'microsoft.network/bastionhosts' ||
-            !sourceEtag ||
-            !location ||
-            !tags ||
-            !skuName ||
-            zones === false) {
-            return undefined;
-        }
-        if (!isPlainRecord(value['properties']) ||
-            !hasOnlyFields(value['properties'], [
-                'provisioningState',
-                'dnsName',
-                'publicUri',
-                'scaleUnits',
-                'disableCopyPaste',
-                'enableFileCopy',
-                'enableIpConnect',
-                'enableShareableLink',
-                'enableTunneling',
-                'enableKerberos',
-                'enableSessionRecording',
-                'enablePrivateOnlyBastion',
-                'ipConfigurations',
-                'networkAcls',
-                'virtualNetwork',
-            ]) ||
-            value['properties']['provisioningState'] !== 'Succeeded' ||
-            value['properties']['networkAcls'] !== undefined ||
-            value['properties']['virtualNetwork'] !== undefined) {
-            return undefined;
-        }
-        const properties = value['properties'];
-        const scaleUnits = properties['scaleUnits'];
-        if (typeof scaleUnits !== 'number' ||
-            !Number.isInteger(scaleUnits) ||
-            (skuName === 'Basic' ? scaleUnits !== 2 : scaleUnits < 2 || scaleUnits > 50)) {
-            return undefined;
-        }
-        const disableCopyPaste = readBoolean(properties['disableCopyPaste']);
-        const enableFileCopy = readBoolean(properties['enableFileCopy']);
-        const enableIpConnect = readBoolean(properties['enableIpConnect']);
-        const enableShareableLink = readBoolean(properties['enableShareableLink']);
-        const enableTunneling = readBoolean(properties['enableTunneling']);
-        const enableKerberos = readBoolean(properties['enableKerberos']);
-        const enableSessionRecording = readBoolean(properties['enableSessionRecording']);
-        const enablePrivateOnlyBastion = readBoolean(properties['enablePrivateOnlyBastion']);
-        if (disableCopyPaste === undefined ||
-            enableFileCopy === undefined ||
-            enableIpConnect === undefined ||
-            enableShareableLink === undefined ||
-            enableTunneling === undefined ||
-            enableKerberos === undefined ||
-            enableSessionRecording !== false ||
-            enablePrivateOnlyBastion !== false ||
-            (skuName === 'Basic' && (enableFileCopy || enableIpConnect || enableShareableLink || enableTunneling || enableKerberos))) {
-            return undefined;
-        }
-        const configurations = properties['ipConfigurations'];
-        if (!Array.isArray(configurations) || configurations.length !== 1)
-            return undefined;
-        const configuration = configurations[0];
-        if (!isPlainRecord(configuration) ||
-            !hasOnlyFields(configuration, ['name', 'id', 'etag', 'type', 'properties']) ||
-            !isPlainRecord(configuration['properties']) ||
-            !hasOnlyFields(configuration['properties'], ['provisioningState', 'privateIPAllocationMethod', 'publicIPAddress', 'subnet']) ||
-            (configuration['properties']['provisioningState'] !== undefined && configuration['properties']['provisioningState'] !== 'Succeeded') ||
-            configuration['properties']['privateIPAllocationMethod'] !== 'Dynamic') {
-            return undefined;
-        }
-        const ipConfigurationName = readString(configuration['name'], MAX_IP_CONFIGURATION_NAME_LENGTH);
-        const publicIp = configuration['properties']['publicIPAddress'];
-        const subnet = configuration['properties']['subnet'];
-        if (!ipConfigurationName ||
-            !isPlainRecord(publicIp) ||
-            !hasOnlyFields(publicIp, ['id']) ||
-            !isPlainRecord(subnet) ||
-            !hasOnlyFields(subnet, ['id'])) {
-            return undefined;
-        }
-        const publicIpId = normalizeResourceId(publicIp['id']);
-        const subnetId = normalizeResourceId(subnet['id']);
-        const publicIpMatch = publicIpId
-            ? /^\/subscriptions\/([a-z0-9-]+)\/resourcegroups\/[a-z0-9._()-]+\/providers\/microsoft\.network\/publicipaddresses\/[a-z0-9._()-]+$/.exec(publicIpId)
-            : undefined;
-        const subnetMatch = subnetId
-            ? /^\/subscriptions\/([a-z0-9-]+)\/resourcegroups\/[a-z0-9._()-]+\/providers\/microsoft\.network\/virtualnetworks\/[a-z0-9._()-]+\/subnets\/azurebastionsubnet$/.exec(subnetId)
-            : undefined;
-        if (!publicIpId ||
-            !publicIpMatch ||
-            publicIpMatch[1] !== bastionSubscriptionId ||
-            !subnetId ||
-            !subnetMatch ||
-            subnetMatch[1] !== bastionSubscriptionId) {
-            return undefined;
-        }
-        return {
-            skuName,
-            location,
-            ...(zones ? { zones } : {}),
-            scaleUnits,
-            disableCopyPaste,
-            enableFileCopy,
-            enableIpConnect,
-            enableShareableLink,
-            enableTunneling,
-            enableKerberos,
-            enableSessionRecording: false,
-            enablePrivateOnlyBastion: false,
-            tags,
-            ipConfigurationName,
-            publicIpId,
-            subnetId,
-            virtualNetworkId: subnetId.slice(0, subnetId.lastIndexOf('/subnets/')),
-            sourceEtag,
-        };
-    }
-    catch {
-        return undefined;
-    }
-}