@kensio/yulin 1.21.0 → 1.21.1

package/dist/service/backup/cfn/sim-cfn-backup-property-reader.js

@@ -0,0 +1,62 @@
+import { isRecord } from "../../../util/type-guard/record.js";
+import { simCfnBackupResourceError } from "./sim-cfn-backup-resource-error.js";
+/** Provides typed access to AWS Backup CloudFormation properties. */
+export class SimCfnBackupPropertyReader {
+    resource;
+    values;
+    constructor(resource, properties) {
+        this.resource = resource;
+        this.values = new Map(Object.entries(properties));
+    }
+    requiredString(name) {
+        const value = this.string(name);
+        if (value === undefined || value.length === 0) {
+            throw this.error(`${name} is required`);
+        }
+        return value;
+    }
+    string(name) {
+        return this.optionalString(this.values.get(name), name);
+    }
+    optionalString(value, name) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== "string")
+            throw this.error(`${name} must be a string`);
+        return value;
+    }
+    requiredRecordString(record, name) {
+        const value = this.optionalString(this.recordValue(record, name), name);
+        if (value === undefined || value.length === 0) {
+            throw this.error(`${name} is required`);
+        }
+        return value;
+    }
+    optionalNumber(value, name) {
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== "number")
+            throw this.error(`${name} must be a number`);
+        return value;
+    }
+    stringArray(value, name) {
+        if (value === undefined)
+            return undefined;
+        if (!Array.isArray(value) ||
+            !value.every((item) => typeof item === "string")) {
+            throw this.error(`${name} must be an array of strings`);
+        }
+        return value;
+    }
+    record(value, name) {
+        if (!isRecord(value))
+            throw this.error(`${name} must be an object`);
+        return value;
+    }
+    recordValue(record, name) {
+        return new Map(Object.entries(record)).get(name);
+    }
+    error(reason) {
+        return simCfnBackupResourceError(this.resource.type ?? "AWS::Backup::Unknown", this.resource.logicalId, reason);
+    }
+}

package/dist/service/backup/cfn/sim-cfn-backup-resource-error.d.ts

@@ -0,0 +1,7 @@
+export declare const backupVaultResourceType = "AWS::Backup::BackupVault";
+export declare const backupPlanResourceType = "AWS::Backup::BackupPlan";
+export declare const backupSelectionResourceType = "AWS::Backup::BackupSelection";
+/** Creates an error for invalid AWS Backup CloudFormation resources. */
+export declare function simCfnBackupResourceError(resourceType: string, logicalId: string, reason: string, cause?: unknown): Error;
+/** Rewrites AWS Backup command errors with CloudFormation resource context. */
+export declare function simCfnBackupResourceCreation<T>(resourceType: string, logicalId: string, create: () => Promise<T>): Promise<T>;

package/dist/service/backup/cfn/sim-cfn-backup-resource-error.js

@@ -0,0 +1,22 @@
+import { SimBackupError } from "../error/sim-backup.error.js";
+export const backupVaultResourceType = "AWS::Backup::BackupVault";
+export const backupPlanResourceType = "AWS::Backup::BackupPlan";
+export const backupSelectionResourceType = "AWS::Backup::BackupSelection";
+/** Creates an error for invalid AWS Backup CloudFormation resources. */
+export function simCfnBackupResourceError(resourceType, logicalId, reason, cause) {
+    return new Error(`Invalid ${resourceType} Resource ${logicalId}: ${reason}`, {
+        cause,
+    });
+}
+/** Rewrites AWS Backup command errors with CloudFormation resource context. */
+export async function simCfnBackupResourceCreation(resourceType, logicalId, create) {
+    try {
+        return await create();
+    }
+    catch (error) {
+        if (error instanceof SimBackupError) {
+            throw simCfnBackupResourceError(resourceType, logicalId, error.message, error);
+        }
+        throw error;
+    }
+}

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

@@ -0,0 +1,11 @@
+import type { SimIamInterServiceAuthZ } from "../../iam/authorize/sim-iam-inter-service-auth-z.js";
+import type { SimBackupRequestOptions } from "./sim-backup-request-options.js";
+/**
+ *
+ */
+export declare class SimBackupAuthorizer {
+    private readonly iam;
+    private readonly callerIdentifier;
+    constructor(iam: SimIamInterServiceAuthZ);
+    authorize(action: string, resource: string, options?: SimBackupRequestOptions): void;
+}

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

@@ -0,0 +1,24 @@
+import { SimIamCallerIdentifier } from "../../iam/error/sim-iam-caller-identifier.js";
+import { SimBackupAccessDeniedException } from "../error/sim-backup.error.js";
+/**
+ *
+ */
+export class SimBackupAuthorizer {
+    iam;
+    callerIdentifier = new SimIamCallerIdentifier();
+    constructor(iam) {
+        this.iam = iam;
+    }
+    authorize(action, resource, options) {
+        const decision = this.iam.authorize({
+            action,
+            resource,
+            caller: options?.caller,
+        });
+        if (decision.isDenied) {
+            const caller = this.callerIdentifier.format(decision.caller.principal);
+            throw new SimBackupAccessDeniedException(`User: ${caller} is not authorized to perform: ${action} on ` +
+                `resource: ${resource}`);
+        }
+    }
+}

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

@@ -0,0 +1,238 @@
+export interface SimBackupLifecycle {
+    readonly MoveToColdStorageAfterDays?: number | undefined;
+    readonly DeleteAfterDays?: number | undefined;
+}
+export interface SimBackupRuleInput {
+    readonly RuleName?: string | undefined;
+    readonly TargetBackupVaultName?: string | undefined;
+    readonly ScheduleExpression?: string | undefined;
+    readonly Lifecycle?: SimBackupLifecycle | undefined;
+}
+export interface SimBackupRule extends SimBackupRuleInput {
+    readonly RuleId: string;
+    readonly RuleName: string;
+    readonly TargetBackupVaultName: string;
+    readonly ScheduleExpression: string;
+}
+export interface SimRecoveryPointCreator {
+    readonly BackupPlanId?: string | undefined;
+    readonly BackupPlanArn?: string | undefined;
+    readonly BackupPlanName?: string | undefined;
+    readonly BackupPlanVersion?: string | undefined;
+    readonly BackupRuleId?: string | undefined;
+    readonly BackupRuleName?: string | undefined;
+}
+export interface SimCalculatedLifecycle {
+    readonly MoveToColdStorageAt?: Date | undefined;
+    readonly DeleteAt?: Date | undefined;
+}
+export interface SimBackupPlanInput {
+    readonly BackupPlanName?: string | undefined;
+    readonly Rules?: readonly SimBackupRuleInput[] | undefined;
+}
+export interface SimBackupSelectionInput {
+    readonly SelectionName?: string | undefined;
+    readonly IamRoleArn?: string | undefined;
+    readonly Resources?: readonly string[] | undefined;
+}
+export interface SimBackupCommand<Input> {
+    readonly input: Input;
+}
+export type SimCreateBackupVaultCommand = SimBackupCommand<{
+    readonly BackupVaultName?: string | undefined;
+    readonly BackupVaultTags?: Readonly<Record<string, string>> | undefined;
+    readonly EncryptionKeyArn?: string | undefined;
+    readonly CreatorRequestId?: string | undefined;
+}>;
+export interface SimCreateBackupVaultCommandOutput {
+    readonly BackupVaultName?: string | undefined;
+    readonly BackupVaultArn?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+}
+export type SimDescribeBackupVaultCommand = SimBackupCommand<{
+    readonly BackupVaultName?: string | undefined;
+}>;
+export interface SimDescribeBackupVaultCommandOutput {
+    readonly BackupVaultName?: string | undefined;
+    readonly BackupVaultArn?: string | undefined;
+    readonly EncryptionKeyArn?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly CreatorRequestId?: string | undefined;
+    readonly NumberOfRecoveryPoints?: number | undefined;
+    readonly Locked?: boolean | undefined;
+    readonly MinRetentionDays?: number | undefined;
+    readonly MaxRetentionDays?: number | undefined;
+    readonly LockDate?: Date | undefined;
+}
+export type SimDeleteBackupVaultCommand = SimDescribeBackupVaultCommand;
+export type SimDeleteBackupVaultCommandOutput = object;
+export type SimListBackupVaultsCommand = SimBackupCommand<{
+    readonly MaxResults?: number | undefined;
+    readonly NextToken?: string | undefined;
+}>;
+export interface SimBackupVaultListMember {
+    readonly BackupVaultName?: string | undefined;
+    readonly BackupVaultArn?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly EncryptionKeyArn?: string | undefined;
+    readonly CreatorRequestId?: string | undefined;
+    readonly NumberOfRecoveryPoints?: number | undefined;
+    readonly Locked?: boolean | undefined;
+    readonly MinRetentionDays?: number | undefined;
+    readonly MaxRetentionDays?: number | undefined;
+    readonly LockDate?: Date | undefined;
+}
+export interface SimListBackupVaultsCommandOutput {
+    readonly BackupVaultList?: readonly SimBackupVaultListMember[] | undefined;
+    readonly NextToken?: string | undefined;
+}
+export type SimPutBackupVaultLockConfigurationCommand = SimBackupCommand<{
+    readonly BackupVaultName?: string | undefined;
+    readonly MinRetentionDays?: number | undefined;
+    readonly MaxRetentionDays?: number | undefined;
+    readonly ChangeableForDays?: number | undefined;
+}>;
+export type SimPutBackupVaultLockConfigurationCommandOutput = object;
+export type SimCreateBackupPlanCommand = SimBackupCommand<{
+    readonly BackupPlan?: SimBackupPlanInput | undefined;
+    readonly CreatorRequestId?: string | undefined;
+}>;
+export interface SimCreateBackupPlanCommandOutput {
+    readonly BackupPlanId?: string | undefined;
+    readonly BackupPlanArn?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly VersionId?: string | undefined;
+}
+export type SimGetBackupPlanCommand = SimBackupCommand<{
+    readonly BackupPlanId?: string | undefined;
+    readonly VersionId?: string | undefined;
+}>;
+export interface SimGetBackupPlanCommandOutput {
+    readonly BackupPlan?: {
+        readonly BackupPlanName?: string | undefined;
+        readonly Rules?: readonly SimBackupRule[] | undefined;
+    };
+    readonly BackupPlanId?: string | undefined;
+    readonly BackupPlanArn?: string | undefined;
+    readonly VersionId?: string | undefined;
+    readonly CreatorRequestId?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+}
+export type SimCreateBackupSelectionCommand = SimBackupCommand<{
+    readonly BackupPlanId?: string | undefined;
+    readonly BackupSelection?: SimBackupSelectionInput | undefined;
+    readonly CreatorRequestId?: string | undefined;
+}>;
+export interface SimCreateBackupSelectionCommandOutput {
+    readonly SelectionId?: string | undefined;
+    readonly BackupPlanId?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+}
+export type SimGetBackupSelectionCommand = SimBackupCommand<{
+    readonly BackupPlanId?: string | undefined;
+    readonly SelectionId?: string | undefined;
+}>;
+export interface SimGetBackupSelectionCommandOutput {
+    readonly BackupSelection?: SimBackupSelectionInput | undefined;
+    readonly SelectionId?: string | undefined;
+    readonly BackupPlanId?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly CreatorRequestId?: string | undefined;
+}
+export type SimListBackupSelectionsCommand = SimBackupCommand<{
+    readonly BackupPlanId?: string | undefined;
+    readonly MaxResults?: number | undefined;
+    readonly NextToken?: string | undefined;
+}>;
+export interface SimBackupSelectionListMember {
+    readonly SelectionId?: string | undefined;
+    readonly SelectionName?: string | undefined;
+    readonly BackupPlanId?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly CreatorRequestId?: string | undefined;
+    readonly IamRoleArn?: string | undefined;
+}
+export interface SimListBackupSelectionsCommandOutput {
+    readonly BackupSelectionsList?: readonly SimBackupSelectionListMember[] | undefined;
+    readonly NextToken?: string | undefined;
+}
+export type SimStartBackupJobCommand = SimBackupCommand<{
+    readonly BackupVaultName?: string | undefined;
+    readonly ResourceArn?: string | undefined;
+    readonly IamRoleArn?: string | undefined;
+    readonly IdempotencyToken?: string | undefined;
+    readonly Lifecycle?: SimBackupLifecycle | undefined;
+}>;
+export interface SimStartBackupJobCommandOutput {
+    readonly BackupJobId?: string | undefined;
+    readonly RecoveryPointArn?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly IsParent?: boolean | undefined;
+}
+export type SimDescribeBackupJobCommand = SimBackupCommand<{
+    readonly BackupJobId?: string | undefined;
+}>;
+export interface SimBackupJobOutput {
+    readonly AccountId?: string | undefined;
+    readonly BackupJobId?: string | undefined;
+    readonly BackupVaultName?: string | undefined;
+    readonly BackupVaultArn?: string | undefined;
+    readonly RecoveryPointArn?: string | undefined;
+    readonly ResourceArn?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly InitiationDate?: Date | undefined;
+    readonly CompletionDate?: Date | undefined;
+    readonly State?: string | undefined;
+    readonly StatusMessage?: string | undefined;
+    readonly PercentDone?: string | undefined;
+    readonly IamRoleArn?: string | undefined;
+    readonly CreatedBy?: SimRecoveryPointCreator | undefined;
+    readonly RecoveryPointLifecycle?: SimBackupLifecycle | undefined;
+    readonly IsParent?: boolean | undefined;
+    readonly MessageCategory?: string | undefined;
+}
+export type SimDescribeBackupJobCommandOutput = SimBackupJobOutput;
+export type SimListBackupJobsCommand = SimBackupCommand<{
+    readonly ByResourceArn?: string | undefined;
+    readonly ByState?: string | undefined;
+    readonly ByBackupVaultName?: string | undefined;
+    readonly MaxResults?: number | undefined;
+    readonly NextToken?: string | undefined;
+}>;
+export interface SimListBackupJobsCommandOutput {
+    readonly BackupJobs?: readonly SimBackupJobOutput[] | undefined;
+    readonly NextToken?: string | undefined;
+}
+export interface SimRecoveryPointOutput {
+    readonly RecoveryPointArn?: string | undefined;
+    readonly BackupVaultName?: string | undefined;
+    readonly BackupVaultArn?: string | undefined;
+    readonly ResourceArn?: string | undefined;
+    readonly CreatedBy?: SimRecoveryPointCreator | undefined;
+    readonly IamRoleArn?: string | undefined;
+    readonly Status?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly InitiationDate?: Date | undefined;
+    readonly CompletionDate?: Date | undefined;
+    readonly CalculatedLifecycle?: SimCalculatedLifecycle | undefined;
+    readonly Lifecycle?: SimBackupLifecycle | undefined;
+    readonly EncryptionKeyArn?: string | undefined;
+    readonly IsEncrypted?: boolean | undefined;
+    readonly VaultType?: string | undefined;
+}
+export type SimListRecoveryPointsByBackupVaultCommand = SimBackupCommand<{
+    readonly BackupVaultName?: string | undefined;
+    readonly ByResourceArn?: string | undefined;
+    readonly ByBackupPlanId?: string | undefined;
+    readonly MaxResults?: number | undefined;
+    readonly NextToken?: string | undefined;
+}>;
+export interface SimListRecoveryPointsByBackupVaultCommandOutput {
+    readonly RecoveryPoints?: readonly SimRecoveryPointOutput[] | undefined;
+    readonly NextToken?: string | undefined;
+}
+export type SimDescribeRecoveryPointCommand = SimBackupCommand<{
+    readonly BackupVaultName?: string | undefined;
+    readonly RecoveryPointArn?: string | undefined;
+}>;
+export type SimDescribeRecoveryPointCommandOutput = SimRecoveryPointOutput;

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

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

package/dist/service/backup/command/sim-backup-configuration-commands.d.ts

@@ -0,0 +1,32 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimBackupPlanSchedules } from "../plan/sim-backup-plan-schedules.js";
+import type { SimBackupResourceResolver } from "../sim-backup-resource-resolver.js";
+import type { SimBackupStore } from "../sim-backup-store.js";
+import type { SimBackupAuthorizer } from "./sim-backup-authorizer.js";
+import type * as commands from "./sim-backup-command.types.js";
+import type { SimBackupRequestOptions } from "./sim-backup-request-options.js";
+interface SimBackupConfigurationCommandsProperties {
+    readonly scope: SimAwsAccountRegionScope;
+    readonly background: BackgroundScheduler;
+    readonly authorizer: SimBackupAuthorizer;
+    readonly resolver: SimBackupResourceResolver;
+    readonly store: SimBackupStore;
+    readonly schedules: SimBackupPlanSchedules;
+}
+/** Handles backup vault, plan and selection commands. */
+export declare class SimBackupConfigurationCommands {
+    private readonly properties;
+    constructor(properties: SimBackupConfigurationCommandsProperties);
+    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>;
+}
+export {};

package/dist/service/backup/command/sim-backup-configuration-commands.js

@@ -0,0 +1,138 @@
+import { randomUUID } from "node:crypto";
+import { SimBackupPlan } from "../plan/sim-backup-plan.js";
+import { SimBackupSelection } from "../selection/sim-backup-selection.js";
+import { backupPlanArn, backupVaultArn } from "../sim-backup-arn.js";
+import { SimBackupVault } from "../vault/sim-backup-vault.js";
+import { requiredString } from "./sim-backup-required-string.js";
+/** Handles backup vault, plan and selection commands. */
+export class SimBackupConfigurationCommands {
+    properties;
+    constructor(properties) {
+        this.properties = properties;
+    }
+    async createBackupVault(command, options) {
+        const { background, scope, authorizer, store } = this.properties;
+        await background.sequence();
+        const name = requiredString(command.input.BackupVaultName, "BackupVaultName");
+        const arn = backupVaultArn(name, scope);
+        authorizer.authorize("backup:CreateBackupVault", arn, options);
+        const vault = new SimBackupVault({
+            name,
+            arn,
+            creationDate: background.now(),
+            encryptionKeyArn: command.input.EncryptionKeyArn,
+            creatorRequestId: command.input.CreatorRequestId,
+            background,
+        });
+        store.addVault(vault);
+        return {
+            BackupVaultName: vault.name,
+            BackupVaultArn: vault.arn,
+            CreationDate: new Date(vault.creationDate),
+        };
+    }
+    async describeBackupVault(command, options) {
+        const { background, resolver } = this.properties;
+        await background.sequence();
+        return resolver
+            .authorizedVault("backup:DescribeBackupVault", command.input.BackupVaultName, options)
+            .describe();
+    }
+    async deleteBackupVault(command, options) {
+        const { background, resolver, store } = this.properties;
+        await background.sequence();
+        const vault = resolver.authorizedVault("backup:DeleteBackupVault", command.input.BackupVaultName, options);
+        vault.assertEmpty();
+        store.removeVault(vault.name);
+        return {};
+    }
+    async listBackupVaults(_command, options) {
+        const { background, authorizer, store } = this.properties;
+        await background.sequence();
+        authorizer.authorize("backup:ListBackupVaults", "*", options);
+        return {
+            BackupVaultList: store
+                .allVaults()
+                .map((vault) => vault.listMember())
+                .toArray(),
+        };
+    }
+    async putBackupVaultLockConfiguration(command, options) {
+        const { background, resolver } = this.properties;
+        await background.sequence();
+        resolver
+            .authorizedVault("backup:PutBackupVaultLockConfiguration", command.input.BackupVaultName, options)
+            .configureLock(command.input, background.now());
+        return {};
+    }
+    async createBackupPlan(command, options) {
+        const { background, scope, authorizer, resolver, store, schedules } = this.properties;
+        await background.sequence();
+        const id = randomUUID();
+        const arn = backupPlanArn(id, scope);
+        authorizer.authorize("backup:CreateBackupPlan", arn, options);
+        const plan = new SimBackupPlan({
+            id,
+            arn,
+            versionId: randomUUID(),
+            creationDate: background.now(),
+            creatorRequestId: command.input.CreatorRequestId,
+            plan: command.input.BackupPlan ?? {},
+        });
+        for (const rule of plan.rules) {
+            resolver.requireVault(rule.TargetBackupVaultName);
+        }
+        store.addPlan(plan);
+        schedules.arm(plan);
+        return {
+            BackupPlanId: plan.id,
+            BackupPlanArn: plan.arn,
+            VersionId: plan.versionId,
+            CreationDate: new Date(plan.creationDate),
+        };
+    }
+    async getBackupPlan(command, options) {
+        const { background, resolver } = this.properties;
+        await background.sequence();
+        return resolver
+            .authorizedPlan("backup:GetBackupPlan", command.input.BackupPlanId, options)
+            .describe();
+    }
+    async createBackupSelection(command, options) {
+        const { background, resolver, store } = this.properties;
+        await background.sequence();
+        const plan = resolver.authorizedPlan("backup:CreateBackupSelection", command.input.BackupPlanId, options);
+        const selection = new SimBackupSelection({
+            id: randomUUID(),
+            planId: plan.id,
+            creationDate: background.now(),
+            creatorRequestId: command.input.CreatorRequestId,
+            selection: command.input.BackupSelection ?? {},
+        });
+        store.addSelection(selection);
+        return {
+            SelectionId: selection.id,
+            BackupPlanId: plan.id,
+            CreationDate: new Date(selection.creationDate),
+        };
+    }
+    async getBackupSelection(command, options) {
+        const { background, resolver } = this.properties;
+        await background.sequence();
+        const plan = resolver.authorizedPlan("backup:GetBackupSelection", command.input.BackupPlanId, options);
+        return resolver
+            .requireSelection(plan.id, command.input.SelectionId)
+            .describe();
+    }
+    async listBackupSelections(command, options) {
+        const { background, resolver, store } = this.properties;
+        await background.sequence();
+        const plan = resolver.authorizedPlan("backup:ListBackupSelections", command.input.BackupPlanId, options);
+        return {
+            BackupSelectionsList: store
+                .selectionsForPlan(plan.id)
+                .map((selection) => selection.listMember())
+                .toArray(),
+        };
+    }
+}

package/dist/service/backup/command/sim-backup-job-commands.d.ts

@@ -0,0 +1,23 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimBackupJobs } from "../job/sim-backup-jobs.js";
+import type { SimBackupResourceResolver } from "../sim-backup-resource-resolver.js";
+import type { SimBackupStore } from "../sim-backup-store.js";
+import type { SimBackupAuthorizer } from "./sim-backup-authorizer.js";
+import type * as commands from "./sim-backup-command.types.js";
+import type { SimBackupRequestOptions } from "./sim-backup-request-options.js";
+interface SimBackupJobCommandsProperties {
+    readonly background: BackgroundScheduler;
+    readonly authorizer: SimBackupAuthorizer;
+    readonly resolver: SimBackupResourceResolver;
+    readonly store: SimBackupStore;
+    readonly jobs: SimBackupJobs;
+}
+/** Handles backup job commands. */
+export declare class SimBackupJobCommands {
+    private readonly properties;
+    constructor(properties: SimBackupJobCommandsProperties);
+    start(command: commands.SimStartBackupJobCommand, options?: SimBackupRequestOptions): Promise<commands.SimStartBackupJobCommandOutput>;
+    describe(command: commands.SimDescribeBackupJobCommand, options?: SimBackupRequestOptions): Promise<commands.SimDescribeBackupJobCommandOutput>;
+    list(command: commands.SimListBackupJobsCommand, options?: SimBackupRequestOptions): Promise<commands.SimListBackupJobsCommandOutput>;
+}
+export {};

package/dist/service/backup/command/sim-backup-job-commands.js

@@ -0,0 +1,52 @@
+import { SimBackupResourceNotFoundException } from "../error/sim-backup.error.js";
+import { SimBackupJobPage } from "../job/sim-backup-job-page.js";
+import { readBackupLifecycle } from "../plan/sim-backup-rule.js";
+import { requiredString } from "./sim-backup-required-string.js";
+/** Handles backup job commands. */
+export class SimBackupJobCommands {
+    properties;
+    constructor(properties) {
+        this.properties = properties;
+    }
+    async start(command, options) {
+        const { background, resolver, jobs } = this.properties;
+        await background.sequence();
+        const vault = resolver.authorizedVault("backup:StartBackupJob", command.input.BackupVaultName, options);
+        const job = jobs.start({
+            vault,
+            resourceArn: requiredString(command.input.ResourceArn, "ResourceArn"),
+            iamRoleArn: requiredString(command.input.IamRoleArn, "IamRoleArn"),
+            at: background.now(),
+            idempotencyToken: command.input.IdempotencyToken,
+            lifecycle: readBackupLifecycle(command.input.Lifecycle),
+        });
+        const output = job.describe();
+        return {
+            BackupJobId: job.id,
+            RecoveryPointArn: output.RecoveryPointArn,
+            CreationDate: output.CreationDate,
+            IsParent: false,
+        };
+    }
+    async describe(command, options) {
+        const { background, authorizer, store } = this.properties;
+        await background.sequence();
+        const id = requiredString(command.input.BackupJobId, "BackupJobId");
+        authorizer.authorize("backup:DescribeBackupJob", "*", options);
+        const job = store.job(id);
+        if (job === undefined) {
+            throw new SimBackupResourceNotFoundException(`Backup job ${id} does not exist`);
+        }
+        return job.describe();
+    }
+    async list(command, options) {
+        const { background, authorizer, store } = this.properties;
+        await background.sequence();
+        authorizer.authorize("backup:ListBackupJobs", "*", options);
+        const page = new SimBackupJobPage(store.allJobs().toArray(), command.input);
+        return {
+            BackupJobs: page.jobs.map((job) => job.describe()),
+            NextToken: page.nextToken,
+        };
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimBackupResourceResolver } from "../sim-backup-resource-resolver.js";
+import type { SimBackupAuthorizer } from "./sim-backup-authorizer.js";
+import type * as commands from "./sim-backup-command.types.js";
+import type { SimBackupRequestOptions } from "./sim-backup-request-options.js";
+interface SimBackupRecoveryPointCommandsProperties {
+    readonly background: BackgroundScheduler;
+    readonly authorizer: SimBackupAuthorizer;
+    readonly resolver: SimBackupResourceResolver;
+}
+/** Handles recovery point read commands. */
+export declare class SimBackupRecoveryPointCommands {
+    private readonly properties;
+    constructor(properties: SimBackupRecoveryPointCommandsProperties);
+    list(command: commands.SimListRecoveryPointsByBackupVaultCommand, options?: SimBackupRequestOptions): Promise<commands.SimListRecoveryPointsByBackupVaultCommandOutput>;
+    describe(command: commands.SimDescribeRecoveryPointCommand, options?: SimBackupRequestOptions): Promise<commands.SimDescribeRecoveryPointCommandOutput>;
+}
+export {};