@kensio/yulin 1.21.0 → 1.21.1

package/dist/service/backup/sim-backup.js

@@ -0,0 +1,139 @@
+import { BackgroundTasks, } from "../../util/background/background.js";
+import { simAwsAccountRegionScopeFactory } from "../aws/sim-aws-account-region-scope.factory.js";
+import { simIamInRegion } from "../iam/authorize/sim-iam-region-auth-z.js";
+import { SimBackupConfigurationCommands } from "./command/sim-backup-configuration-commands.js";
+import { SimBackupAuthorizer } from "./command/sim-backup-authorizer.js";
+import { SimBackupJobCommands } from "./command/sim-backup-job-commands.js";
+import { SimBackupRecoveryPointCommands } from "./command/sim-backup-recovery-point-commands.js";
+import { SimBackupPlanSchedules } from "./plan/sim-backup-plan-schedules.js";
+import { SimBackupResourceResolver } from "./sim-backup-resource-resolver.js";
+import { SimBackupStore } from "./sim-backup-store.js";
+import { SimBackupJobs } from "./job/sim-backup-jobs.js";
+import { SimBackupSdkCommandRouter } from "./sdk/sim-backup-sdk-command-router.js";
+import { SimBackupCfnResourceFactory } from "./cfn/sim-backup-cfn-resource-factory.js";
+/** Simulates AWS Backup resources in one account and Region. */
+export class SimBackup {
+    store = new SimBackupStore();
+    scope;
+    background;
+    authorizer;
+    resolver;
+    jobs;
+    schedules;
+    jobCommands;
+    recoveryPointCommands;
+    configurationCommands;
+    sdkRouter = new SimBackupSdkCommandRouter(this);
+    cfnFactory = new SimBackupCfnResourceFactory({
+        backup: this,
+    });
+    constructor(properties = {}) {
+        this.scope =
+            properties.accountRegionScope ?? simAwsAccountRegionScopeFactory.make();
+        this.background = properties.background ?? new BackgroundTasks();
+        this.authorizer = new SimBackupAuthorizer(simIamInRegion(properties.iam, this.scope.regionName));
+        this.resolver = new SimBackupResourceResolver({
+            scope: this.scope,
+            authorizer: this.authorizer,
+            store: this.store,
+        });
+        this.jobs = new SimBackupJobs({ scope: this.scope, store: this.store });
+        this.schedules = new SimBackupPlanSchedules({
+            store: this.store,
+            jobs: this.jobs,
+            background: this.background,
+        });
+        this.jobCommands = new SimBackupJobCommands({
+            background: this.background,
+            authorizer: this.authorizer,
+            resolver: this.resolver,
+            store: this.store,
+            jobs: this.jobs,
+        });
+        this.recoveryPointCommands = new SimBackupRecoveryPointCommands({
+            background: this.background,
+            authorizer: this.authorizer,
+            resolver: this.resolver,
+        });
+        this.configurationCommands = new SimBackupConfigurationCommands({
+            scope: this.scope,
+            background: this.background,
+            authorizer: this.authorizer,
+            resolver: this.resolver,
+            store: this.store,
+            schedules: this.schedules,
+        });
+    }
+    async createBackupVault(command, options) {
+        return await this.configurationCommands.createBackupVault(command, options);
+    }
+    async describeBackupVault(command, options) {
+        return await this.configurationCommands.describeBackupVault(command, options);
+    }
+    async deleteBackupVault(command, options) {
+        return await this.configurationCommands.deleteBackupVault(command, options);
+    }
+    async listBackupVaults(_command, options) {
+        return await this.configurationCommands.listBackupVaults(_command, options);
+    }
+    async putBackupVaultLockConfiguration(command, options) {
+        return await this.configurationCommands.putBackupVaultLockConfiguration(command, options);
+    }
+    async createBackupPlan(command, options) {
+        return await this.configurationCommands.createBackupPlan(command, options);
+    }
+    async getBackupPlan(command, options) {
+        return await this.configurationCommands.getBackupPlan(command, options);
+    }
+    async createBackupSelection(command, options) {
+        return await this.configurationCommands.createBackupSelection(command, options);
+    }
+    async getBackupSelection(command, options) {
+        return await this.configurationCommands.getBackupSelection(command, options);
+    }
+    async listBackupSelections(command, options) {
+        return await this.configurationCommands.listBackupSelections(command, options);
+    }
+    async startBackupJob(command, options) {
+        return await this.jobCommands.start(command, options);
+    }
+    async describeBackupJob(command, options) {
+        return await this.jobCommands.describe(command, options);
+    }
+    async listBackupJobs(command, options) {
+        return await this.jobCommands.list(command, options);
+    }
+    async listRecoveryPointsByBackupVault(command, options) {
+        return await this.recoveryPointCommands.list(command, options);
+    }
+    async describeRecoveryPoint(command, options) {
+        return await this.recoveryPointCommands.describe(command, options);
+    }
+    vault(name) {
+        return this.resolver.requireVault(name);
+    }
+    findBackupVault(name) {
+        return this.store.vault(name);
+    }
+    findBackupPlan(id) {
+        return this.store.plan(id);
+    }
+    findBackupSelection(id) {
+        return this.store.selection(id);
+    }
+    removeBackupVault(name) {
+        this.store.removeVault(name);
+    }
+    removeBackupPlan(id) {
+        this.store.removePlan(id);
+    }
+    removeBackupSelection(id) {
+        this.store.removeSelection(id);
+    }
+    sdkCommandRouter() {
+        return this.sdkRouter;
+    }
+    cfnResourceFactory() {
+        return this.cfnFactory;
+    }
+}

package/dist/service/backup/vault/sim-backup-vault-description.d.ts

@@ -0,0 +1,12 @@
+import type { SimDescribeBackupVaultCommandOutput } from "../command/sim-backup-command.types.js";
+import type { SimBackupVaultLockConfiguration } from "./sim-backup-vault-lock.js";
+interface SimBackupVaultDescriptionSource {
+    readonly name: string;
+    readonly arn: string;
+    readonly creationDate: Date;
+    readonly encryptionKeyArn?: string | undefined;
+    readonly creatorRequestId?: string | undefined;
+}
+/** Builds the SDK description of one backup vault. */
+export declare function describeBackupVault(vault: SimBackupVaultDescriptionSource, lock: SimBackupVaultLockConfiguration | undefined, lockDate: Date | undefined, recoveryPointCount: number): SimDescribeBackupVaultCommandOutput;
+export {};

package/dist/service/backup/vault/sim-backup-vault-description.js

@@ -0,0 +1,15 @@
+/** Builds the SDK description of one backup vault. */
+export function describeBackupVault(vault, lock, lockDate, recoveryPointCount) {
+    return {
+        BackupVaultName: vault.name,
+        BackupVaultArn: vault.arn,
+        EncryptionKeyArn: vault.encryptionKeyArn,
+        CreationDate: new Date(vault.creationDate),
+        CreatorRequestId: vault.creatorRequestId,
+        NumberOfRecoveryPoints: recoveryPointCount,
+        Locked: lock !== undefined,
+        MinRetentionDays: lock?.MinRetentionDays,
+        MaxRetentionDays: lock?.MaxRetentionDays,
+        LockDate: lockDate === undefined ? undefined : new Date(lockDate),
+    };
+}

package/dist/service/backup/vault/sim-backup-vault-lock-configuration.d.ts

@@ -0,0 +1,5 @@
+import type { SimBackupVaultLockConfiguration } from "./sim-backup-vault-lock.js";
+/** Calculates when a Vault Lock grace period ends. */
+export declare function backupVaultLockDate(changeableForDays: number | undefined, now: Date): Date | undefined;
+/** Validates a Vault Lock configuration before storage. */
+export declare function validateBackupVaultLockConfiguration(configuration: SimBackupVaultLockConfiguration): void;

package/dist/service/backup/vault/sim-backup-vault-lock-configuration.js

@@ -0,0 +1,31 @@
+import { SimBackupInvalidParameterValueException } from "../error/sim-backup.error.js";
+const millisecondsPerDay = 24 * 60 * 60 * 1000;
+/** Calculates when a Vault Lock grace period ends. */
+export function backupVaultLockDate(changeableForDays, now) {
+    if (changeableForDays === undefined) {
+        return undefined;
+    }
+    return new Date(now.getTime() + changeableForDays * millisecondsPerDay);
+}
+/** Validates a Vault Lock configuration before storage. */
+export function validateBackupVaultLockConfiguration(configuration) {
+    const { MinRetentionDays: minimum, MaxRetentionDays: maximum } = configuration;
+    if (minimum !== undefined &&
+        (!Number.isSafeInteger(minimum) || minimum < 1)) {
+        throw new SimBackupInvalidParameterValueException("MinRetentionDays must be a positive whole number");
+    }
+    if (maximum !== undefined &&
+        (!Number.isSafeInteger(maximum) || maximum < 1 || maximum > 36_500)) {
+        throw new SimBackupInvalidParameterValueException("MaxRetentionDays must be between 1 and 36500");
+    }
+    if (minimum !== undefined && maximum !== undefined && minimum > maximum) {
+        throw new SimBackupInvalidParameterValueException("MinRetentionDays must not exceed MaxRetentionDays");
+    }
+    validateGracePeriod(configuration.ChangeableForDays);
+}
+function validateGracePeriod(grace) {
+    if (grace !== undefined &&
+        (!Number.isSafeInteger(grace) || grace < 3 || grace > 36_500)) {
+        throw new SimBackupInvalidParameterValueException("ChangeableForDays must be between 3 and 36500");
+    }
+}

package/dist/service/backup/vault/sim-backup-vault-lock.d.ts

@@ -0,0 +1,15 @@
+import type { SimBackupLifecycle } from "../command/sim-backup-command.types.js";
+export interface SimBackupVaultLockConfiguration {
+    readonly MinRetentionDays?: number | undefined;
+    readonly MaxRetentionDays?: number | undefined;
+    readonly ChangeableForDays?: number | undefined;
+}
+/** Holds the Vault Lock state for one backup vault. */
+export declare class SimBackupVaultLock {
+    private readonly vaultName;
+    configuration?: SimBackupVaultLockConfiguration | undefined;
+    lockDate?: Date | undefined;
+    constructor(vaultName: string);
+    configure(configuration: SimBackupVaultLockConfiguration, now: Date): void;
+    lifecycleRefusal(lifecycle: SimBackupLifecycle | undefined): string | undefined;
+}

package/dist/service/backup/vault/sim-backup-vault-lock.js

@@ -0,0 +1,23 @@
+import { SimBackupInvalidParameterValueException } from "../error/sim-backup.error.js";
+import { backupVaultLockDate, validateBackupVaultLockConfiguration, } from "./sim-backup-vault-lock-configuration.js";
+import { backupLifecycleRefusal } from "./sim-backup-vault-retention.js";
+/** Holds the Vault Lock state for one backup vault. */
+export class SimBackupVaultLock {
+    vaultName;
+    configuration;
+    lockDate;
+    constructor(vaultName) {
+        this.vaultName = vaultName;
+    }
+    configure(configuration, now) {
+        if (this.lockDate !== undefined && now >= this.lockDate) {
+            throw new SimBackupInvalidParameterValueException(`The lock configuration for backup vault ${this.vaultName} is immutable`);
+        }
+        validateBackupVaultLockConfiguration(configuration);
+        this.configuration = { ...configuration };
+        this.lockDate = backupVaultLockDate(configuration.ChangeableForDays, now);
+    }
+    lifecycleRefusal(lifecycle) {
+        return backupLifecycleRefusal(lifecycle, this.configuration);
+    }
+}

package/dist/service/backup/vault/sim-backup-vault-recovery-points.d.ts

@@ -0,0 +1,12 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimBackupRecoveryPoint } from "../recovery-point/sim-backup-recovery-point.js";
+/** Holds the unexpired recovery points in one backup vault. */
+export declare class SimBackupVaultRecoveryPoints {
+    private readonly background;
+    private readonly stored;
+    constructor(background: BackgroundScheduler);
+    add(recoveryPoint: SimBackupRecoveryPoint): void;
+    all(): readonly SimBackupRecoveryPoint[];
+    find(arn: string): SimBackupRecoveryPoint | undefined;
+    private expire;
+}

package/dist/service/backup/vault/sim-backup-vault-recovery-points.js

@@ -0,0 +1,30 @@
+/** Holds the unexpired recovery points in one backup vault. */
+export class SimBackupVaultRecoveryPoints {
+    background;
+    stored = new Map();
+    constructor(background) {
+        this.background = background;
+    }
+    add(recoveryPoint) {
+        this.stored.set(recoveryPoint.arn, recoveryPoint);
+    }
+    all() {
+        this.expire();
+        return this.stored.values().toArray();
+    }
+    find(arn) {
+        this.expire();
+        return this.stored.get(arn);
+    }
+    expire() {
+        const now = this.background.now();
+        const expired = this.stored
+            .values()
+            .filter((point) => point.isExpired(now))
+            .map((point) => point.arn)
+            .toArray();
+        for (const arn of expired) {
+            this.stored.delete(arn);
+        }
+    }
+}

package/dist/service/backup/vault/sim-backup-vault-retention.d.ts

@@ -0,0 +1,4 @@
+import type { SimBackupLifecycle } from "../command/sim-backup-command.types.js";
+import type { SimBackupVaultLockConfiguration } from "./sim-backup-vault-lock.js";
+/** Returns the Vault Lock reason that rejects a recovery point lifecycle. */
+export declare function backupLifecycleRefusal(lifecycle: SimBackupLifecycle | undefined, lock: SimBackupVaultLockConfiguration | undefined): string | undefined;

package/dist/service/backup/vault/sim-backup-vault-retention.js

@@ -0,0 +1,20 @@
+/** Returns the Vault Lock reason that rejects a recovery point lifecycle. */
+export function backupLifecycleRefusal(lifecycle, lock) {
+    const retention = lifecycle?.DeleteAfterDays;
+    const minimum = lock?.MinRetentionDays;
+    if (minimum !== undefined &&
+        retention !== undefined &&
+        retention !== -1 &&
+        retention < minimum) {
+        return `Lifecycle retention of ${retention} days is below the vault minimum of ${minimum} days`;
+    }
+    const maximum = lock?.MaxRetentionDays;
+    if (maximum === undefined ||
+        (retention !== undefined && retention !== -1 && retention <= maximum)) {
+        return undefined;
+    }
+    const requested = retention === undefined || retention === -1
+        ? "indefinite"
+        : `${retention} days`;
+    return `Lifecycle retention of ${requested} exceeds the vault maximum of ${maximum} days`;
+}

package/dist/service/backup/vault/sim-backup-vault.d.ts

@@ -0,0 +1,33 @@
+import type { SimBackupVaultListMember, SimDescribeBackupVaultCommandOutput } from "../command/sim-backup-command.types.js";
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimBackupLifecycle } from "../command/sim-backup-command.types.js";
+import type { SimBackupRecoveryPoint } from "../recovery-point/sim-backup-recovery-point.js";
+import { type SimBackupVaultLockConfiguration } from "./sim-backup-vault-lock.js";
+export type { SimBackupVaultLockConfiguration } from "./sim-backup-vault-lock.js";
+interface SimBackupVaultProperties {
+    readonly name: string;
+    readonly arn: string;
+    readonly creationDate: Date;
+    readonly encryptionKeyArn?: string | undefined;
+    readonly creatorRequestId?: string | undefined;
+    readonly background: BackgroundScheduler;
+}
+/** Stores one simulated AWS Backup vault. */
+export declare class SimBackupVault {
+    readonly name: string;
+    readonly arn: string;
+    readonly creationDate: Date;
+    readonly encryptionKeyArn?: string | undefined;
+    readonly creatorRequestId?: string | undefined;
+    private readonly lock;
+    private readonly points;
+    constructor(properties: SimBackupVaultProperties);
+    configureLock(configuration: SimBackupVaultLockConfiguration, now: Date): void;
+    describe(): SimDescribeBackupVaultCommandOutput;
+    listMember(): SimBackupVaultListMember;
+    addRecoveryPoint(recoveryPoint: SimBackupRecoveryPoint): void;
+    recoveryPoints(): readonly SimBackupRecoveryPoint[];
+    recoveryPoint(arn: string): SimBackupRecoveryPoint | undefined;
+    assertEmpty(): void;
+    lifecycleRefusal(lifecycle: SimBackupLifecycle | undefined): string | undefined;
+}

package/dist/service/backup/vault/sim-backup-vault.js

@@ -0,0 +1,49 @@
+import { SimBackupInvalidRequestException } from "../error/sim-backup.error.js";
+import { describeBackupVault } from "./sim-backup-vault-description.js";
+import { SimBackupVaultLock, } from "./sim-backup-vault-lock.js";
+import { SimBackupVaultRecoveryPoints } from "./sim-backup-vault-recovery-points.js";
+/** Stores one simulated AWS Backup vault. */
+export class SimBackupVault {
+    name;
+    arn;
+    creationDate;
+    encryptionKeyArn;
+    creatorRequestId;
+    lock;
+    points;
+    constructor(properties) {
+        this.name = properties.name;
+        this.arn = properties.arn;
+        this.creationDate = new Date(properties.creationDate);
+        this.encryptionKeyArn = properties.encryptionKeyArn;
+        this.creatorRequestId = properties.creatorRequestId;
+        this.lock = new SimBackupVaultLock(this.name);
+        this.points = new SimBackupVaultRecoveryPoints(properties.background);
+    }
+    configureLock(configuration, now) {
+        this.lock.configure(configuration, now);
+    }
+    describe() {
+        return describeBackupVault(this, this.lock.configuration, this.lock.lockDate, this.recoveryPoints().length);
+    }
+    listMember() {
+        return this.describe();
+    }
+    addRecoveryPoint(recoveryPoint) {
+        this.points.add(recoveryPoint);
+    }
+    recoveryPoints() {
+        return this.points.all();
+    }
+    recoveryPoint(arn) {
+        return this.points.find(arn);
+    }
+    assertEmpty() {
+        if (this.recoveryPoints().length > 0) {
+            throw new SimBackupInvalidRequestException(`Backup vault ${this.name} cannot be deleted while it contains recovery points`);
+        }
+    }
+    lifecycleRefusal(lifecycle) {
+        return this.lock.lifecycleRefusal(lifecycle);
+    }
+}

package/dist/service/cloudformation/resource/cfn/backup/sim-backup-cfn-value-adapter.d.ts

@@ -0,0 +1,3 @@
+import type { SimCfnResourceValueAdapterProperties, SimCfnServiceValueAdapter } from "../sim-cfn-resource-value-adapter.js";
+/** Returns the CloudFormation value adapter for an AWS Backup resource. */
+export declare function backupValueAdapter(properties: SimCfnResourceValueAdapterProperties): SimCfnServiceValueAdapter;

package/dist/service/cloudformation/resource/cfn/backup/sim-backup-cfn-value-adapter.js

@@ -0,0 +1,66 @@
+import { SimBackupPlan } from "../../../../backup/plan/sim-backup-plan.js";
+import { SimBackupSelection } from "../../../../backup/selection/sim-backup-selection.js";
+import { SimBackupVault } from "../../../../backup/vault/sim-backup-vault.js";
+class SimBackupVaultCfn {
+    vault;
+    constructor(vault) {
+        this.vault = vault;
+    }
+    refValue() {
+        return this.vault.name;
+    }
+    attributeValue(name) {
+        if (name === "BackupVaultArn")
+            return this.vault.arn;
+        if (name === "BackupVaultName")
+            return this.vault.name;
+        throw new Error(`Unsupported AWS::Backup::BackupVault attribute ${name}`);
+    }
+}
+class SimBackupPlanCfn {
+    plan;
+    constructor(plan) {
+        this.plan = plan;
+    }
+    refValue() {
+        return this.plan.id;
+    }
+    attributeValue(name) {
+        if (name === "BackupPlanArn")
+            return this.plan.arn;
+        if (name === "BackupPlanId")
+            return this.plan.id;
+        if (name === "VersionId")
+            return this.plan.versionId;
+        throw new Error(`Unsupported AWS::Backup::BackupPlan attribute ${name}`);
+    }
+}
+class SimBackupSelectionCfn {
+    selection;
+    constructor(selection) {
+        this.selection = selection;
+    }
+    refValue() {
+        return this.selection.id;
+    }
+    attributeValue(name) {
+        if (name === "BackupPlanId")
+            return this.selection.planId;
+        if (name === "Id" || name === "SelectionId")
+            return this.selection.id;
+        throw new Error(`Unsupported AWS::Backup::BackupSelection attribute ${name}`);
+    }
+}
+/** Returns the CloudFormation value adapter for an AWS Backup resource. */
+export function backupValueAdapter(properties) {
+    if (properties.simResource instanceof SimBackupVault) {
+        return new SimBackupVaultCfn(properties.simResource);
+    }
+    if (properties.simResource instanceof SimBackupPlan) {
+        return new SimBackupPlanCfn(properties.simResource);
+    }
+    if (properties.simResource instanceof SimBackupSelection) {
+        return new SimBackupSelectionCfn(properties.simResource);
+    }
+    return undefined;
+}

package/dist/service/cloudformation/resource/cfn/logs/sim-logs-cfn-value-adapter.js

@@ -2,10 +2,12 @@ import { SimLogsDeliveryDestination } from "../../../../logs/delivery/sim-logs-d
 import { SimLogsDeliverySource } from "../../../../logs/delivery/sim-logs-delivery-source.js";
 import { SimLogsDelivery } from "../../../../logs/delivery/sim-logs-delivery.js";
 import { SimLogsLogGroup } from "../../../../logs/group/sim-logs-log-group.js";
+import { SimLogsMetricFilter } from "../../../../logs/metric/sim-logs-metric-filter.js";
 import { SimLogsDeliveryDestinationCfn } from "./sim-logs-delivery-destination-cfn.js";
 import { SimLogsDeliverySourceCfn } from "./sim-logs-delivery-source-cfn.js";
 import { SimLogsDeliveryCfn } from "./sim-logs-delivery-cfn.js";
 import { SimLogsLogGroupCfn } from "./sim-logs-log-group-cfn.js";
+import { SimLogsMetricFilterCfn } from "./sim-logs-metric-filter-cfn.js";
 /**
  * The CloudFormation-facing value adapter for a simulated CloudWatch Logs
  * Resource.
@@ -16,6 +18,10 @@ export function logsValueAdapter(properties) {
         simResource instanceof SimLogsLogGroup) {
         return new SimLogsLogGroupCfn({ group: simResource });
     }
+    if (type === "AWS::Logs::MetricFilter" &&
+        simResource instanceof SimLogsMetricFilter) {
+        return new SimLogsMetricFilterCfn({ filter: simResource });
+    }
     if (type === "AWS::Logs::DeliverySource" &&
         simResource instanceof SimLogsDeliverySource) {
         return new SimLogsDeliverySourceCfn({ source: simResource });

package/dist/service/cloudformation/resource/cfn/logs/sim-logs-metric-filter-cfn.d.ts

@@ -0,0 +1,23 @@
+import type { SimLogsMetricFilter } from "../../../../logs/metric/sim-logs-metric-filter.js";
+import type { SimCfnTemplateValue } from "../../../template/value/sim-cfn-template-value.js";
+import type { SimCfnResourceValueAdapter } from "../sim-cfn-resource-value-adapter.js";
+interface SimLogsMetricFilterCfnProperties {
+    readonly filter: SimLogsMetricFilter;
+}
+/**
+ * CloudFormation-facing values for a simulated CloudWatch Logs metric filter.
+ */
+export declare class SimLogsMetricFilterCfn implements SimCfnResourceValueAdapter {
+    #private;
+    constructor(properties: SimLogsMetricFilterCfnProperties);
+    /**
+     * AWS::Logs::MetricFilter Ref returns the filter name.
+     */
+    refValue(): SimCfnTemplateValue;
+    /**
+     * AWS::Logs::MetricFilter attributes, of which real CloudFormation returns
+     * none.
+     */
+    attributeValue(attributeName: string): SimCfnTemplateValue;
+}
+export {};

package/dist/service/cloudformation/resource/cfn/logs/sim-logs-metric-filter-cfn.js

@@ -0,0 +1,22 @@
+/**
+ * CloudFormation-facing values for a simulated CloudWatch Logs metric filter.
+ */
+export class SimLogsMetricFilterCfn {
+    #filter;
+    constructor(properties) {
+        this.#filter = properties.filter;
+    }
+    /**
+     * AWS::Logs::MetricFilter Ref returns the filter name.
+     */
+    refValue() {
+        return this.#filter.filterName;
+    }
+    /**
+     * AWS::Logs::MetricFilter attributes, of which real CloudFormation returns
+     * none.
+     */
+    attributeValue(attributeName) {
+        throw new Error(`Unsupported AWS::Logs::MetricFilter attribute ${attributeName}`);
+    }
+}

package/dist/service/cloudformation/resource/cfn/sim-cfn-service-value-adapters.js

@@ -2,6 +2,7 @@ import { acmValueAdapter } from "./acm/sim-acm-cfn-value-adapter.js";
 import { apiGatewayValueAdapter } from "./apigateway/sim-api-gateway-cfn-value-adapter.js";
 import { apiGatewayV2ValueAdapter } from "./apigatewayv2/sim-api-gateway-v2-cfn-value-adapter.js";
 import { athenaValueAdapter } from "./athena/sim-athena-cfn-value-adapter.js";
+import { backupValueAdapter } from "./backup/sim-backup-cfn-value-adapter.js";
 import { cdkCustomResourceValueAdapter } from "./cdk/sim-cdk-custom-resource-value-adapter.js";
 import { cloudFrontValueAdapter } from "./cloudfront/sim-cloudfront-cfn-value-adapter.js";
 import { cloudWatchValueAdapter } from "./cloudwatch/sim-cloudwatch-cfn-value-adapter.js";
@@ -45,6 +46,7 @@ export const simCfnServiceValueAdapters = [
     apiGatewayValueAdapter,
     apiGatewayV2ValueAdapter,
     athenaValueAdapter,
+    backupValueAdapter,
     cdkCustomResourceValueAdapter,
     cloudFrontValueAdapter,
     cloudWatchValueAdapter,

package/dist/service/cloudformation/resource/ignore/sim-cfn-skipped-properties.d.ts

@@ -0,0 +1,49 @@
+import type { SimCfnTemplateValueRecord } from "../../template/value/sim-cfn-template-value.js";
+import type { SimCfnSkippedPropertyRules } from "./sim-cfn-skipped-property.type.js";
+interface SimCfnSkippedPropertiesProperties {
+    readonly rules: SimCfnSkippedPropertyRules;
+    readonly properties: SimCfnTemplateValueRecord;
+    readonly error: (reason: string) => Error;
+}
+/**
+ * What one Resource's skipped properties say, and what they still have to
+ * satisfy.
+ *
+ * Simulated CloudFormation deploys what it can, so a property a service cannot
+ * act on is recorded against the Resource rather than taking it down. That
+ * leaves a gap. A skipped property can carry a value real AWS answers with a
+ * 400 as readily as a simulated one can, and deploying it here reports a
+ * template AWS refuses as working, which is the one failure a local deploy of
+ * a real template exists to catch.
+ *
+ * This is where a service closes that gap. The constraint sits beside the
+ * reason in the same map, and every service reaches it the same way, so the
+ * next one to need it has nothing to build.
+ */
+export declare class SimCfnSkippedProperties {
+    private readonly rules;
+    private readonly properties;
+    private readonly error;
+    constructor(properties: SimCfnSkippedPropertiesProperties);
+    /**
+     * Refuse the Resource where a skipped value is one real AWS would answer
+     * with a 400.
+     *
+     * Every constraint runs before anything is recorded, so a Resource that
+     * fails one leaves no half-written list of what it was created without.
+     */
+    assertConstraints(): void;
+    /**
+     * Why a property is skipped, or nothing where this service has no entry for
+     * it.
+     */
+    reasonFor(name: string): string | undefined;
+    /**
+     * What a property's value has to satisfy, where the service stated it.
+     *
+     * A rule that is a bare reason states nothing, which is the common case and
+     * the reason both shapes share one map.
+     */
+    private constraintOn;
+}
+export {};