@kensio/yulin 1.20.17 → 1.21.1

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

@@ -0,0 +1,37 @@
+import { requiredString } from "../command/sim-backup-required-string.js";
+import { readBackupRules } from "./sim-backup-rule.js";
+/** Stores one simulated AWS Backup plan. */
+export class SimBackupPlan {
+    id;
+    arn;
+    versionId;
+    creationDate;
+    creatorRequestId;
+    name;
+    rules;
+    constructor(properties) {
+        this.id = properties.id;
+        this.arn = properties.arn;
+        this.versionId = properties.versionId;
+        this.creationDate = new Date(properties.creationDate);
+        this.creatorRequestId = properties.creatorRequestId;
+        this.name = requiredString(properties.plan.BackupPlanName, "BackupPlanName");
+        this.rules = readBackupRules(properties.plan.Rules);
+    }
+    describe() {
+        return {
+            BackupPlan: {
+                BackupPlanName: this.name,
+                Rules: this.rules.map((rule) => ({
+                    ...rule,
+                    Lifecycle: rule.Lifecycle === undefined ? undefined : { ...rule.Lifecycle },
+                })),
+            },
+            BackupPlanId: this.id,
+            BackupPlanArn: this.arn,
+            VersionId: this.versionId,
+            CreatorRequestId: this.creatorRequestId,
+            CreationDate: new Date(this.creationDate),
+        };
+    }
+}

package/dist/service/backup/plan/sim-backup-rule.d.ts

@@ -0,0 +1,9 @@
+import type { SimScheduleDialect } from "../../../util/schedule/sim-schedule-dialect.js";
+import type { SimBackupRule, SimBackupRuleInput } from "../command/sim-backup-command.types.js";
+export declare const defaultBackupScheduleExpression = "cron(0 5 ? * * *)";
+/** Defines the AWS Backup cron dialect used by plan rules. */
+export declare const backupScheduleDialect: SimScheduleDialect;
+/** Reads and validates the rules in a backup plan. */
+export declare function readBackupRules(input: readonly SimBackupRuleInput[] | undefined): readonly SimBackupRule[];
+/** Enforces the relationship between cold storage and deletion. */
+export declare function readBackupLifecycle(lifecycle: SimBackupRuleInput["Lifecycle"]): SimBackupRuleInput["Lifecycle"];

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

@@ -0,0 +1,71 @@
+import { randomUUID } from "node:crypto";
+import { awsCronFieldSpecs } from "../../../util/schedule/cron/sim-cron-field-spec.js";
+import { SimSchedule } from "../../../util/schedule/sim-schedule.js";
+import { SimScheduleExpressionError } from "../../../util/schedule/sim-schedule.error.js";
+import { requiredString } from "../command/sim-backup-required-string.js";
+import { SimBackupInvalidParameterValueException, SimBackupMissingParameterValueException, } from "../error/sim-backup.error.js";
+export const defaultBackupScheduleExpression = "cron(0 5 ? * * *)";
+/** Defines the AWS Backup cron dialect used by plan rules. */
+export const backupScheduleDialect = {
+    cronFields: awsCronFieldSpecs,
+    requiresRateAgreement: true,
+    allowsOneTime: false,
+};
+/** Reads and validates the rules in a backup plan. */
+export function readBackupRules(input) {
+    if (input === undefined || input.length === 0) {
+        throw new SimBackupMissingParameterValueException("BackupPlan.Rules must contain at least one rule");
+    }
+    return input.map((rule) => readBackupRule(rule));
+}
+/** Validates and normalizes one backup plan rule for storage. */
+function readBackupRule(input) {
+    const schedule = input.ScheduleExpression ?? defaultBackupScheduleExpression;
+    validateSchedule(schedule);
+    const lifecycle = readBackupLifecycle(input.Lifecycle);
+    return {
+        RuleId: randomUUID(),
+        RuleName: requiredString(input.RuleName, "RuleName"),
+        TargetBackupVaultName: requiredString(input.TargetBackupVaultName, "TargetBackupVaultName"),
+        ScheduleExpression: schedule,
+        Lifecycle: lifecycle,
+    };
+}
+/** Rejects expressions outside the AWS Backup schedule dialect. */
+function validateSchedule(schedule) {
+    try {
+        SimSchedule.of(schedule, backupScheduleDialect);
+    }
+    catch (error) {
+        if (error instanceof SimScheduleExpressionError) {
+            throw new SimBackupInvalidParameterValueException(error.message);
+        }
+        throw error;
+    }
+}
+/** Enforces the relationship between cold storage and deletion. */
+export function readBackupLifecycle(lifecycle) {
+    const coldAfter = lifecycle?.MoveToColdStorageAfterDays;
+    const deleteAfter = lifecycle?.DeleteAfterDays;
+    const retainedIndefinitely = coldAfter === -1 && deleteAfter === -1;
+    for (const [name, days] of [
+        ["MoveToColdStorageAfterDays", coldAfter],
+        ["DeleteAfterDays", deleteAfter],
+    ]) {
+        if (days !== undefined &&
+            days !== -1 &&
+            (!Number.isSafeInteger(days) || days < 1 || days > 36_500)) {
+            throw new SimBackupInvalidParameterValueException(`${name} must be between 1 and 36500`);
+        }
+    }
+    if (!retainedIndefinitely && (coldAfter === -1 || deleteAfter === -1)) {
+        throw new SimBackupInvalidParameterValueException("MoveToColdStorageAfterDays and DeleteAfterDays must both be -1");
+    }
+    if (!retainedIndefinitely &&
+        coldAfter !== undefined &&
+        deleteAfter !== undefined &&
+        deleteAfter < coldAfter + 90) {
+        throw new SimBackupInvalidParameterValueException("DeleteAfterDays must be at least 90 days after MoveToColdStorageAfterDays");
+    }
+    return lifecycle === undefined ? undefined : { ...lifecycle };
+}

package/dist/service/backup/recovery-point/sim-backup-recovery-point.d.ts

@@ -0,0 +1,28 @@
+import type { SimBackupLifecycle, SimRecoveryPointCreator, SimRecoveryPointOutput } from "../command/sim-backup-command.types.js";
+interface SimBackupRecoveryPointProperties {
+    readonly arn: string;
+    readonly vaultName: string;
+    readonly vaultArn: string;
+    readonly resourceArn: string;
+    readonly iamRoleArn: string;
+    readonly creationDate: Date;
+    readonly lifecycle?: SimBackupLifecycle | undefined;
+    readonly createdBy?: SimRecoveryPointCreator | undefined;
+    readonly encryptionKeyArn?: string | undefined;
+}
+/** A completed recovery point stored in a simulated backup vault. */
+export declare class SimBackupRecoveryPoint {
+    readonly arn: string;
+    readonly vaultName: string;
+    readonly vaultArn: string;
+    readonly resourceArn: string;
+    readonly iamRoleArn: string;
+    readonly creationDate: Date;
+    readonly lifecycle?: SimBackupLifecycle | undefined;
+    readonly createdBy?: SimRecoveryPointCreator | undefined;
+    readonly encryptionKeyArn?: string | undefined;
+    constructor(properties: SimBackupRecoveryPointProperties);
+    isExpired(now: Date): boolean;
+    describe(): SimRecoveryPointOutput;
+}
+export {};

package/dist/service/backup/recovery-point/sim-backup-recovery-point.factory.d.ts

@@ -0,0 +1,9 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { StartSimBackupJob } from "../job/sim-backup-job-input.js";
+import { SimBackupRecoveryPoint } from "./sim-backup-recovery-point.js";
+/** Creates a recovery point from a successful backup attempt. */
+export declare class SimBackupRecoveryPointFactory {
+    private readonly scope;
+    constructor(scope: SimAwsAccountRegionScope);
+    make(input: StartSimBackupJob): SimBackupRecoveryPoint;
+}

package/dist/service/backup/recovery-point/sim-backup-recovery-point.factory.js

@@ -0,0 +1,23 @@
+import { randomUUID } from "node:crypto";
+import { recoveryPointArn } from "../sim-backup-arn.js";
+import { SimBackupRecoveryPoint } from "./sim-backup-recovery-point.js";
+/** Creates a recovery point from a successful backup attempt. */
+export class SimBackupRecoveryPointFactory {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    make(input) {
+        return new SimBackupRecoveryPoint({
+            arn: recoveryPointArn(randomUUID(), this.scope),
+            vaultName: input.vault.name,
+            vaultArn: input.vault.arn,
+            resourceArn: input.resourceArn,
+            iamRoleArn: input.iamRoleArn,
+            creationDate: input.at,
+            lifecycle: input.lifecycle,
+            createdBy: input.createdBy,
+            encryptionKeyArn: input.vault.encryptionKeyArn,
+        });
+    }
+}

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

@@ -0,0 +1,62 @@
+const millisecondsPerDay = 24 * 60 * 60 * 1000;
+/** A completed recovery point stored in a simulated backup vault. */
+export class SimBackupRecoveryPoint {
+    arn;
+    vaultName;
+    vaultArn;
+    resourceArn;
+    iamRoleArn;
+    creationDate;
+    lifecycle;
+    createdBy;
+    encryptionKeyArn;
+    constructor(properties) {
+        this.arn = properties.arn;
+        this.vaultName = properties.vaultName;
+        this.vaultArn = properties.vaultArn;
+        this.resourceArn = properties.resourceArn;
+        this.iamRoleArn = properties.iamRoleArn;
+        this.creationDate = new Date(properties.creationDate);
+        this.lifecycle =
+            properties.lifecycle === undefined
+                ? undefined
+                : { ...properties.lifecycle };
+        this.createdBy =
+            properties.createdBy === undefined
+                ? undefined
+                : { ...properties.createdBy };
+        this.encryptionKeyArn = properties.encryptionKeyArn;
+    }
+    isExpired(now) {
+        const deleteAt = lifecycleDate(this.creationDate, this.lifecycle?.DeleteAfterDays);
+        return deleteAt !== undefined && now >= deleteAt;
+    }
+    describe() {
+        return {
+            RecoveryPointArn: this.arn,
+            BackupVaultName: this.vaultName,
+            BackupVaultArn: this.vaultArn,
+            ResourceArn: this.resourceArn,
+            CreatedBy: this.createdBy === undefined ? undefined : { ...this.createdBy },
+            IamRoleArn: this.iamRoleArn,
+            Status: "COMPLETED",
+            CreationDate: new Date(this.creationDate),
+            InitiationDate: new Date(this.creationDate),
+            CompletionDate: new Date(this.creationDate),
+            CalculatedLifecycle: {
+                MoveToColdStorageAt: lifecycleDate(this.creationDate, this.lifecycle?.MoveToColdStorageAfterDays),
+                DeleteAt: lifecycleDate(this.creationDate, this.lifecycle?.DeleteAfterDays),
+            },
+            Lifecycle: this.lifecycle === undefined ? undefined : { ...this.lifecycle },
+            EncryptionKeyArn: this.encryptionKeyArn,
+            IsEncrypted: true,
+            VaultType: "BACKUP_VAULT",
+        };
+    }
+}
+function lifecycleDate(createdAt, days) {
+    if (days === undefined || days === -1) {
+        return undefined;
+    }
+    return new Date(createdAt.getTime() + days * millisecondsPerDay);
+}

package/dist/service/backup/sdk/sim-backup-sdk-command-router.d.ts

@@ -0,0 +1,9 @@
+import { type SimSdkCommandRoute, type SimSdkCommandRouter } from "../../../sdk/index.js";
+import type { SimBackup } from "../sim-backup.js";
+/** Routes supported BackupClient commands to simulated AWS Backup. */
+export declare class SimBackupSdkCommandRouter implements SimSdkCommandRouter {
+    private readonly routes;
+    constructor(backup: SimBackup);
+    supportedCommandNames(): readonly string[];
+    route(commandName: string): SimSdkCommandRoute | undefined;
+}

package/dist/service/backup/sdk/sim-backup-sdk-command-router.js

@@ -0,0 +1,37 @@
+import { simSdkCallerOptions, } from "../../../sdk/index.js";
+/** Routes supported BackupClient commands to simulated AWS Backup. */
+export class SimBackupSdkCommandRouter {
+    routes;
+    constructor(backup) {
+        this.routes = new Map([
+            route("CreateBackupVaultCommand", (command, options) => backup.createBackupVault(command, options)),
+            route("DescribeBackupVaultCommand", (command, options) => backup.describeBackupVault(command, options)),
+            route("DeleteBackupVaultCommand", (command, options) => backup.deleteBackupVault(command, options)),
+            route("ListBackupVaultsCommand", (command, options) => backup.listBackupVaults(command, options)),
+            route("PutBackupVaultLockConfigurationCommand", (command, options) => backup.putBackupVaultLockConfiguration(command, options)),
+            route("CreateBackupPlanCommand", (command, options) => backup.createBackupPlan(command, options)),
+            route("GetBackupPlanCommand", (command, options) => backup.getBackupPlan(command, options)),
+            route("CreateBackupSelectionCommand", (command, options) => backup.createBackupSelection(command, options)),
+            route("GetBackupSelectionCommand", (command, options) => backup.getBackupSelection(command, options)),
+            route("ListBackupSelectionsCommand", (command, options) => backup.listBackupSelections(command, options)),
+            route("StartBackupJobCommand", (command, options) => backup.startBackupJob(command, options)),
+            route("DescribeBackupJobCommand", (command, options) => backup.describeBackupJob(command, options)),
+            route("ListBackupJobsCommand", (command, options) => backup.listBackupJobs(command, options)),
+            route("ListRecoveryPointsByBackupVaultCommand", (command, options) => backup.listRecoveryPointsByBackupVault(command, options)),
+            route("DescribeRecoveryPointCommand", (command, options) => backup.describeRecoveryPoint(command, options)),
+        ]);
+    }
+    supportedCommandNames() {
+        return this.routes.keys().toArray();
+    }
+    route(commandName) {
+        return this.routes.get(commandName);
+    }
+}
+/** Builds one route with caller options from the interception context. */
+function route(name, handle) {
+    return [
+        name,
+        async (command, context) => await handle(command, simSdkCallerOptions(context)),
+    ];
+}

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

@@ -0,0 +1,22 @@
+import type { SimBackupSelectionInput, SimBackupSelectionListMember, SimGetBackupSelectionCommandOutput } from "../command/sim-backup-command.types.js";
+interface SimBackupSelectionProperties {
+    readonly id: string;
+    readonly planId: string;
+    readonly creationDate: Date;
+    readonly creatorRequestId?: string | undefined;
+    readonly selection: SimBackupSelectionInput;
+}
+/** Stored configuration for one selection in a backup plan. */
+export declare class SimBackupSelection {
+    readonly id: string;
+    readonly planId: string;
+    readonly creationDate: Date;
+    readonly creatorRequestId?: string | undefined;
+    readonly name: string;
+    readonly iamRoleArn: string;
+    readonly resources: readonly string[];
+    constructor(properties: SimBackupSelectionProperties);
+    describe(): SimGetBackupSelectionCommandOutput;
+    listMember(): SimBackupSelectionListMember;
+}
+export {};

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

@@ -0,0 +1,43 @@
+import { requiredString } from "../command/sim-backup-required-string.js";
+/** Stored configuration for one selection in a backup plan. */
+export class SimBackupSelection {
+    id;
+    planId;
+    creationDate;
+    creatorRequestId;
+    name;
+    iamRoleArn;
+    resources;
+    constructor(properties) {
+        this.id = properties.id;
+        this.planId = properties.planId;
+        this.creationDate = new Date(properties.creationDate);
+        this.creatorRequestId = properties.creatorRequestId;
+        this.name = requiredString(properties.selection.SelectionName, "SelectionName");
+        this.iamRoleArn = requiredString(properties.selection.IamRoleArn, "IamRoleArn");
+        this.resources = [...(properties.selection.Resources ?? [])];
+    }
+    describe() {
+        return {
+            BackupSelection: {
+                SelectionName: this.name,
+                IamRoleArn: this.iamRoleArn,
+                Resources: [...this.resources],
+            },
+            SelectionId: this.id,
+            BackupPlanId: this.planId,
+            CreationDate: new Date(this.creationDate),
+            CreatorRequestId: this.creatorRequestId,
+        };
+    }
+    listMember() {
+        return {
+            SelectionId: this.id,
+            SelectionName: this.name,
+            BackupPlanId: this.planId,
+            CreationDate: new Date(this.creationDate),
+            CreatorRequestId: this.creatorRequestId,
+            IamRoleArn: this.iamRoleArn,
+        };
+    }
+}

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

@@ -0,0 +1,7 @@
+import type { SimAwsAccountRegionScope } from "../aws/sim-aws-account-region-scope.js";
+/** Builds the ARN of a backup vault in the supplied scope. */
+export declare function backupVaultArn(name: string, scope: SimAwsAccountRegionScope): string;
+/** Builds the ARN of a backup plan in the supplied scope. */
+export declare function backupPlanArn(id: string, scope: SimAwsAccountRegionScope): string;
+/** Builds the ARN of a recovery point in the supplied scope. */
+export declare function recoveryPointArn(id: string, scope: SimAwsAccountRegionScope): string;

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

@@ -0,0 +1,12 @@
+/** Builds the ARN of a backup vault in the supplied scope. */
+export function backupVaultArn(name, scope) {
+    return `arn:aws:backup:${scope.regionName}:${scope.accountId}:backup-vault:${name}`;
+}
+/** Builds the ARN of a backup plan in the supplied scope. */
+export function backupPlanArn(id, scope) {
+    return `arn:aws:backup:${scope.regionName}:${scope.accountId}:backup-plan:${id}`;
+}
+/** Builds the ARN of a recovery point in the supplied scope. */
+export function recoveryPointArn(id, scope) {
+    return `arn:aws:backup:${scope.regionName}:${scope.accountId}:recovery-point:${id}`;
+}

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

@@ -0,0 +1,8 @@
+import type { BackgroundScheduler } from "../../util/background/background.js";
+import type { SimAwsAccountRegionScope } from "../aws/sim-aws-account-region-scope.js";
+import type { SimIamInterServiceAuthZ } from "../iam/authorize/sim-iam-inter-service-auth-z.js";
+export interface SimBackupProperties {
+    readonly accountRegionScope?: SimAwsAccountRegionScope;
+    readonly iam?: SimIamInterServiceAuthZ;
+    readonly background?: BackgroundScheduler;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/service/backup/sim-backup-resource-resolver.d.ts

@@ -0,0 +1,24 @@
+import type { SimAwsAccountRegionScope } from "../aws/sim-aws-account-region-scope.js";
+import type { SimBackupRequestOptions } from "./command/sim-backup-request-options.js";
+import type { SimBackupAuthorizer } from "./command/sim-backup-authorizer.js";
+import type { SimBackupPlan } from "./plan/sim-backup-plan.js";
+import type { SimBackupSelection } from "./selection/sim-backup-selection.js";
+import type { SimBackupStore } from "./sim-backup-store.js";
+import type { SimBackupVault } from "./vault/sim-backup-vault.js";
+interface SimBackupResourceResolverProperties {
+    readonly scope: SimAwsAccountRegionScope;
+    readonly authorizer: SimBackupAuthorizer;
+    readonly store: SimBackupStore;
+}
+/** Resolves AWS Backup resources after validating the request and IAM policy. */
+export declare class SimBackupResourceResolver {
+    private readonly scope;
+    private readonly authorizer;
+    private readonly store;
+    constructor(properties: SimBackupResourceResolverProperties);
+    authorizedVault(action: string, requestedName: string | undefined, options?: SimBackupRequestOptions): SimBackupVault;
+    authorizedPlan(action: string, requestedId: string | undefined, options?: SimBackupRequestOptions): SimBackupPlan;
+    requireVault(name: string | undefined): SimBackupVault;
+    requireSelection(planId: string, requestedId: string | undefined): SimBackupSelection;
+}
+export {};

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

@@ -0,0 +1,44 @@
+import { requiredString } from "./command/sim-backup-required-string.js";
+import { SimBackupResourceNotFoundException } from "./error/sim-backup.error.js";
+import { backupPlanArn, backupVaultArn } from "./sim-backup-arn.js";
+/** Resolves AWS Backup resources after validating the request and IAM policy. */
+export class SimBackupResourceResolver {
+    scope;
+    authorizer;
+    store;
+    constructor(properties) {
+        this.scope = properties.scope;
+        this.authorizer = properties.authorizer;
+        this.store = properties.store;
+    }
+    authorizedVault(action, requestedName, options) {
+        const name = requiredString(requestedName, "BackupVaultName");
+        this.authorizer.authorize(action, backupVaultArn(name, this.scope), options);
+        return this.requireVault(name);
+    }
+    authorizedPlan(action, requestedId, options) {
+        const id = requiredString(requestedId, "BackupPlanId");
+        this.authorizer.authorize(action, backupPlanArn(id, this.scope), options);
+        const plan = this.store.plan(id);
+        if (plan === undefined) {
+            throw new SimBackupResourceNotFoundException(`Backup plan ${id} does not exist`);
+        }
+        return plan;
+    }
+    requireVault(name) {
+        const required = requiredString(name, "TargetBackupVaultName");
+        const vault = this.store.vault(required);
+        if (vault === undefined) {
+            throw new SimBackupResourceNotFoundException(`Backup vault ${required} does not exist`);
+        }
+        return vault;
+    }
+    requireSelection(planId, requestedId) {
+        const id = requiredString(requestedId, "SelectionId");
+        const selection = this.store.selection(id);
+        if (selection === undefined || selection.planId !== planId) {
+            throw new SimBackupResourceNotFoundException(`Backup selection ${id} does not exist in plan ${planId}`);
+        }
+        return selection;
+    }
+}

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

@@ -0,0 +1,29 @@
+import type { SimBackupJob } from "./job/sim-backup-job.js";
+import type { SimBackupPlan } from "./plan/sim-backup-plan.js";
+import type { SimBackupSelection } from "./selection/sim-backup-selection.js";
+import type { SimBackupVault } from "./vault/sim-backup-vault.js";
+/**
+ * Holds AWS Backup resources for one simulated account and Region.
+ */
+export declare class SimBackupStore {
+    private readonly vaults;
+    private readonly plans;
+    private readonly selections;
+    private readonly jobs;
+    private readonly jobsByIdempotencyToken;
+    addVault(vault: SimBackupVault): void;
+    vault(name: string): SimBackupVault | undefined;
+    allVaults(): MapIterator<SimBackupVault>;
+    removeVault(name: string): void;
+    addPlan(plan: SimBackupPlan): void;
+    plan(id: string): SimBackupPlan | undefined;
+    removePlan(id: string): void;
+    addSelection(selection: SimBackupSelection): void;
+    selection(id: string): SimBackupSelection | undefined;
+    selectionsForPlan(planId: string): IteratorObject<SimBackupSelection>;
+    removeSelection(id: string): void;
+    addJob(job: SimBackupJob, idempotencyToken?: string): void;
+    job(id: string): SimBackupJob | undefined;
+    jobByIdempotencyToken(token: string): SimBackupJob | undefined;
+    allJobs(): MapIterator<SimBackupJob>;
+}

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

@@ -0,0 +1,80 @@
+import { SimBackupAlreadyExistsException } from "./error/sim-backup.error.js";
+/**
+ * Holds AWS Backup resources for one simulated account and Region.
+ */
+export class SimBackupStore {
+    vaults = new Map();
+    plans = new Map();
+    selections = new Map();
+    jobs = new Map();
+    jobsByIdempotencyToken = new Map();
+    addVault(vault) {
+        if (this.vaults.has(vault.name)) {
+            throw new SimBackupAlreadyExistsException(`A backup vault named ${vault.name} already exists`);
+        }
+        this.vaults.set(vault.name, vault);
+    }
+    vault(name) {
+        return this.vaults.get(name);
+    }
+    allVaults() {
+        return this.vaults.values();
+    }
+    removeVault(name) {
+        this.vaults.delete(name);
+    }
+    addPlan(plan) {
+        if (this.plans.values().some((stored) => stored.name === plan.name)) {
+            throw new SimBackupAlreadyExistsException(`A backup plan named ${plan.name} already exists`);
+        }
+        this.plans.set(plan.id, plan);
+    }
+    plan(id) {
+        return this.plans.get(id);
+    }
+    removePlan(id) {
+        this.plans.delete(id);
+        const selectionIds = this.selections
+            .values()
+            .filter((selection) => selection.planId === id)
+            .map((selection) => selection.id)
+            .toArray();
+        for (const selectionId of selectionIds)
+            this.selections.delete(selectionId);
+    }
+    addSelection(selection) {
+        if (this.selections
+            .values()
+            .some((stored) => stored.planId === selection.planId &&
+            stored.name === selection.name)) {
+            throw new SimBackupAlreadyExistsException(`A backup selection named ${selection.name} already exists`);
+        }
+        this.selections.set(selection.id, selection);
+    }
+    selection(id) {
+        return this.selections.get(id);
+    }
+    selectionsForPlan(planId) {
+        return this.selections
+            .values()
+            .filter((selection) => selection.planId === planId);
+    }
+    removeSelection(id) {
+        this.selections.delete(id);
+    }
+    addJob(job, idempotencyToken) {
+        this.jobs.set(job.id, job);
+        if (idempotencyToken !== undefined) {
+            this.jobsByIdempotencyToken.set(idempotencyToken, job);
+        }
+    }
+    job(id) {
+        return this.jobs.get(id);
+    }
+    jobByIdempotencyToken(token) {
+        return this.jobsByIdempotencyToken.get(token);
+    }
+    allJobs() {
+        return this.jobs.values();
+    }
+}

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

@@ -0,0 +1,48 @@
+import type { SimSdkCommandRouter } from "../../sdk/router/sim-sdk-command-router.type.js";
+import type * as commands from "./command/sim-backup-command.types.js";
+import type { SimBackupRequestOptions } from "./command/sim-backup-request-options.js";
+import type { SimBackupPlan } from "./plan/sim-backup-plan.js";
+import type { SimBackupSelection } from "./selection/sim-backup-selection.js";
+import type { SimBackupProperties } from "./sim-backup-properties.js";
+import type { SimBackupVault } from "./vault/sim-backup-vault.js";
+import { SimBackupCfnResourceFactory } from "./cfn/sim-backup-cfn-resource-factory.js";
+/** Simulates AWS Backup resources in one account and Region. */
+export declare class SimBackup {
+    private readonly store;
+    private readonly scope;
+    private readonly background;
+    private readonly authorizer;
+    private readonly resolver;
+    private readonly jobs;
+    private readonly schedules;
+    private readonly jobCommands;
+    private readonly recoveryPointCommands;
+    private readonly configurationCommands;
+    private readonly sdkRouter;
+    private readonly cfnFactory;
+    constructor(properties?: SimBackupProperties);
+    createBackupVault(command: commands.SimCreateBackupVaultCommand, options?: SimBackupRequestOptions): Promise<commands.SimCreateBackupVaultCommandOutput>;
+    describeBackupVault(command: commands.SimDescribeBackupVaultCommand, options?: SimBackupRequestOptions): Promise<commands.SimDescribeBackupVaultCommandOutput>;
+    deleteBackupVault(command: commands.SimDeleteBackupVaultCommand, options?: SimBackupRequestOptions): Promise<commands.SimDeleteBackupVaultCommandOutput>;
+    listBackupVaults(_command: commands.SimListBackupVaultsCommand, options?: SimBackupRequestOptions): Promise<commands.SimListBackupVaultsCommandOutput>;
+    putBackupVaultLockConfiguration(command: commands.SimPutBackupVaultLockConfigurationCommand, options?: SimBackupRequestOptions): Promise<commands.SimPutBackupVaultLockConfigurationCommandOutput>;
+    createBackupPlan(command: commands.SimCreateBackupPlanCommand, options?: SimBackupRequestOptions): Promise<commands.SimCreateBackupPlanCommandOutput>;
+    getBackupPlan(command: commands.SimGetBackupPlanCommand, options?: SimBackupRequestOptions): Promise<commands.SimGetBackupPlanCommandOutput>;
+    createBackupSelection(command: commands.SimCreateBackupSelectionCommand, options?: SimBackupRequestOptions): Promise<commands.SimCreateBackupSelectionCommandOutput>;
+    getBackupSelection(command: commands.SimGetBackupSelectionCommand, options?: SimBackupRequestOptions): Promise<commands.SimGetBackupSelectionCommandOutput>;
+    listBackupSelections(command: commands.SimListBackupSelectionsCommand, options?: SimBackupRequestOptions): Promise<commands.SimListBackupSelectionsCommandOutput>;
+    startBackupJob(command: commands.SimStartBackupJobCommand, options?: SimBackupRequestOptions): Promise<commands.SimStartBackupJobCommandOutput>;
+    describeBackupJob(command: commands.SimDescribeBackupJobCommand, options?: SimBackupRequestOptions): Promise<commands.SimDescribeBackupJobCommandOutput>;
+    listBackupJobs(command: commands.SimListBackupJobsCommand, options?: SimBackupRequestOptions): Promise<commands.SimListBackupJobsCommandOutput>;
+    listRecoveryPointsByBackupVault(command: commands.SimListRecoveryPointsByBackupVaultCommand, options?: SimBackupRequestOptions): Promise<commands.SimListRecoveryPointsByBackupVaultCommandOutput>;
+    describeRecoveryPoint(command: commands.SimDescribeRecoveryPointCommand, options?: SimBackupRequestOptions): Promise<commands.SimDescribeRecoveryPointCommandOutput>;
+    vault(name: string): SimBackupVault;
+    findBackupVault(name: string): SimBackupVault | undefined;
+    findBackupPlan(id: string): SimBackupPlan | undefined;
+    findBackupSelection(id: string): SimBackupSelection | undefined;
+    removeBackupVault(name: string): void;
+    removeBackupPlan(id: string): void;
+    removeBackupSelection(id: string): void;
+    sdkCommandRouter(): SimSdkCommandRouter;
+    cfnResourceFactory(): SimBackupCfnResourceFactory;
+}