@kensio/yulin 1.21.0 → 1.21.1

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

@@ -0,0 +1,38 @@
+import { SimBackupResourceNotFoundException } from "../error/sim-backup.error.js";
+import { requiredString } from "./sim-backup-required-string.js";
+/** Handles recovery point read commands. */
+export class SimBackupRecoveryPointCommands {
+    properties;
+    constructor(properties) {
+        this.properties = properties;
+    }
+    async list(command, options) {
+        const { background, resolver } = this.properties;
+        await background.sequence();
+        const vault = resolver.authorizedVault("backup:ListRecoveryPointsByBackupVault", command.input.BackupVaultName, options);
+        return {
+            RecoveryPoints: vault
+                .recoveryPoints()
+                .filter((point) => matchesPoint(point, command.input))
+                .map((point) => point.describe()),
+        };
+    }
+    async describe(command, options) {
+        const { background, authorizer, resolver } = this.properties;
+        await background.sequence();
+        const arn = requiredString(command.input.RecoveryPointArn, "RecoveryPointArn");
+        authorizer.authorize("backup:DescribeRecoveryPoint", arn, options);
+        const vault = resolver.requireVault(command.input.BackupVaultName);
+        const point = vault.recoveryPoint(arn);
+        if (point === undefined) {
+            throw new SimBackupResourceNotFoundException(`Recovery point ${arn} does not exist in backup vault ${vault.name}`);
+        }
+        return point.describe();
+    }
+}
+function matchesPoint(point, filter) {
+    return ((filter.ByResourceArn === undefined ||
+        point.resourceArn === filter.ByResourceArn) &&
+        (filter.ByBackupPlanId === undefined ||
+            point.createdBy?.BackupPlanId === filter.ByBackupPlanId));
+}

package/dist/service/backup/command/sim-backup-request-options.d.ts

@@ -0,0 +1,4 @@
+import type { SimAwsCaller } from "../../aws/caller/sim-aws-caller.js";
+export interface SimBackupRequestOptions {
+    readonly caller?: SimAwsCaller | undefined;
+}

package/dist/service/backup/command/sim-backup-request-options.js

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

package/dist/service/backup/command/sim-backup-required-string.d.ts

@@ -0,0 +1,2 @@
+/** Reads a required non-empty string from an AWS Backup request. */
+export declare function requiredString(value: string | undefined, name: string): string;

package/dist/service/backup/command/sim-backup-required-string.js

@@ -0,0 +1,8 @@
+import { SimBackupMissingParameterValueException } from "../error/sim-backup.error.js";
+/** Reads a required non-empty string from an AWS Backup request. */
+export function requiredString(value, name) {
+    if (value === undefined || value.length === 0) {
+        throw new SimBackupMissingParameterValueException(`${name} is required`);
+    }
+    return value;
+}

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

@@ -0,0 +1,38 @@
+export interface SimBackupErrorMetadata {
+    readonly httpStatusCode?: number | undefined;
+}
+/** Base class for AWS Backup service errors. */
+export declare class SimBackupError extends Error {
+    readonly $metadata: SimBackupErrorMetadata;
+    constructor(message: string, $metadata?: SimBackupErrorMetadata);
+}
+/** AWS Backup refused the caller's permissions. */
+export declare class SimBackupAccessDeniedException extends SimBackupError {
+    readonly name = "AccessDeniedException";
+    constructor(message: string);
+}
+/** AWS Backup found a resource with the requested identity. */
+export declare class SimBackupAlreadyExistsException extends SimBackupError {
+    readonly name = "AlreadyExistsException";
+    constructor(message: string);
+}
+/** AWS Backup refused a parameter value. */
+export declare class SimBackupInvalidParameterValueException extends SimBackupError {
+    readonly name = "InvalidParameterValueException";
+    constructor(message: string);
+}
+/** AWS Backup refused a request that is invalid for the resource state. */
+export declare class SimBackupInvalidRequestException extends SimBackupError {
+    readonly name = "InvalidRequestException";
+    constructor(message: string);
+}
+/** AWS Backup found a required parameter missing. */
+export declare class SimBackupMissingParameterValueException extends SimBackupError {
+    readonly name = "MissingParameterValueException";
+    constructor(message: string);
+}
+/** AWS Backup could not find the requested resource. */
+export declare class SimBackupResourceNotFoundException extends SimBackupError {
+    readonly name = "ResourceNotFoundException";
+    constructor(message: string);
+}

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

@@ -0,0 +1,50 @@
+/** Base class for AWS Backup service errors. */
+export class SimBackupError extends Error {
+    $metadata;
+    constructor(message, $metadata = {}) {
+        super(message);
+        this.$metadata = $metadata;
+    }
+}
+/** AWS Backup refused the caller's permissions. */
+export class SimBackupAccessDeniedException extends SimBackupError {
+    name = "AccessDeniedException";
+    constructor(message) {
+        super(message, { httpStatusCode: 403 });
+    }
+}
+/** AWS Backup found a resource with the requested identity. */
+export class SimBackupAlreadyExistsException extends SimBackupError {
+    name = "AlreadyExistsException";
+    constructor(message) {
+        super(message, { httpStatusCode: 400 });
+    }
+}
+/** AWS Backup refused a parameter value. */
+export class SimBackupInvalidParameterValueException extends SimBackupError {
+    name = "InvalidParameterValueException";
+    constructor(message) {
+        super(message, { httpStatusCode: 400 });
+    }
+}
+/** AWS Backup refused a request that is invalid for the resource state. */
+export class SimBackupInvalidRequestException extends SimBackupError {
+    name = "InvalidRequestException";
+    constructor(message) {
+        super(message, { httpStatusCode: 400 });
+    }
+}
+/** AWS Backup found a required parameter missing. */
+export class SimBackupMissingParameterValueException extends SimBackupError {
+    name = "MissingParameterValueException";
+    constructor(message) {
+        super(message, { httpStatusCode: 400 });
+    }
+}
+/** AWS Backup could not find the requested resource. */
+export class SimBackupResourceNotFoundException extends SimBackupError {
+    name = "ResourceNotFoundException";
+    constructor(message) {
+        super(message, { httpStatusCode: 400 });
+    }
+}

package/dist/service/backup/index.d.ts

@@ -0,0 +1,9 @@
+export { SimBackup } from "./sim-backup.js";
+export type { SimBackupRequestOptions } from "./command/sim-backup-request-options.js";
+export type { SimBackupLifecycle, SimBackupPlanInput, SimBackupRule, SimBackupRuleInput, SimBackupSelectionInput, } from "./command/sim-backup-command.types.js";
+export { SimBackupPlan } from "./plan/sim-backup-plan.js";
+export { SimBackupJob } from "./job/sim-backup-job.js";
+export { SimBackupRecoveryPoint } from "./recovery-point/sim-backup-recovery-point.js";
+export { SimBackupSelection } from "./selection/sim-backup-selection.js";
+export { SimBackupVault } from "./vault/sim-backup-vault.js";
+export { SimBackupAccessDeniedException, SimBackupAlreadyExistsException, SimBackupError, SimBackupInvalidParameterValueException, SimBackupInvalidRequestException, SimBackupMissingParameterValueException, SimBackupResourceNotFoundException, } from "./error/sim-backup.error.js";

package/dist/service/backup/index.js

@@ -0,0 +1,7 @@
+export { SimBackup } from "./sim-backup.js";
+export { SimBackupPlan } from "./plan/sim-backup-plan.js";
+export { SimBackupJob } from "./job/sim-backup-job.js";
+export { SimBackupRecoveryPoint } from "./recovery-point/sim-backup-recovery-point.js";
+export { SimBackupSelection } from "./selection/sim-backup-selection.js";
+export { SimBackupVault } from "./vault/sim-backup-vault.js";
+export { SimBackupAccessDeniedException, SimBackupAlreadyExistsException, SimBackupError, SimBackupInvalidParameterValueException, SimBackupInvalidRequestException, SimBackupMissingParameterValueException, SimBackupResourceNotFoundException, } from "./error/sim-backup.error.js";

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

@@ -0,0 +1,11 @@
+import type { SimBackupLifecycle, SimRecoveryPointCreator } from "../command/sim-backup-command.types.js";
+import type { SimBackupVault } from "../vault/sim-backup-vault.js";
+export interface StartSimBackupJob {
+    readonly vault: SimBackupVault;
+    readonly resourceArn: string;
+    readonly iamRoleArn: string;
+    readonly at: Date;
+    readonly idempotencyToken?: string | undefined;
+    readonly lifecycle?: SimBackupLifecycle | undefined;
+    readonly createdBy?: SimRecoveryPointCreator | undefined;
+}

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

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

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

@@ -0,0 +1,22 @@
+import type { SimBackupJob } from "./sim-backup-job.js";
+export interface SimBackupJobPageInput {
+    readonly ByResourceArn?: string | undefined;
+    readonly ByState?: string | undefined;
+    readonly ByBackupVaultName?: string | undefined;
+    readonly MaxResults?: number | undefined;
+    readonly NextToken?: string | undefined;
+}
+/** One page of backup jobs and the token for the next page. */
+export declare class SimBackupJobPage {
+    readonly jobs: readonly SimBackupJob[];
+    readonly nextToken: string | undefined;
+    constructor(listed: readonly SimBackupJob[], input: SimBackupJobPageInput);
+    /** Return whether a stored job satisfies all requested filters. */
+    private static matches;
+    /** Read and validate the requested page size. */
+    private static pageSize;
+    /** Read a continuation token as an offset into the filtered jobs. */
+    private static startIndex;
+    /** Issue a continuation token when more jobs remain. */
+    private static tokenFor;
+}

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

@@ -0,0 +1,54 @@
+import { SimBackupInvalidParameterValueException } from "../error/sim-backup.error.js";
+const defaultMaxResults = 1000;
+const maximumMaxResults = 1000;
+/** One page of backup jobs and the token for the next page. */
+export class SimBackupJobPage {
+    jobs;
+    nextToken;
+    constructor(listed, input) {
+        const matching = listed.filter((job) => SimBackupJobPage.matches(job, input));
+        const startIndex = SimBackupJobPage.startIndex(input.NextToken, matching.length);
+        const nextIndex = startIndex + SimBackupJobPage.pageSize(input.MaxResults);
+        this.jobs = matching.slice(startIndex, nextIndex);
+        this.nextToken = SimBackupJobPage.tokenFor(nextIndex, matching.length);
+    }
+    /** Return whether a stored job satisfies all requested filters. */
+    static matches(job, input) {
+        return ((input.ByResourceArn === undefined ||
+            job.resourceArn === input.ByResourceArn) &&
+            (input.ByState === undefined || job.state === input.ByState) &&
+            (input.ByBackupVaultName === undefined ||
+                job.vaultName === input.ByBackupVaultName));
+    }
+    /** Read and validate the requested page size. */
+    static pageSize(requested) {
+        const maxResults = requested ?? defaultMaxResults;
+        if (!Number.isSafeInteger(maxResults) ||
+            maxResults < 1 ||
+            maxResults > maximumMaxResults) {
+            throw new SimBackupInvalidParameterValueException(`MaxResults ${String(requested)} is outside the range 1 to ${String(maximumMaxResults)}`);
+        }
+        return maxResults;
+    }
+    /** Read a continuation token as an offset into the filtered jobs. */
+    static startIndex(nextToken, listedCount) {
+        if (nextToken === undefined) {
+            return 0;
+        }
+        const startIndex = Number(nextToken);
+        if (!Number.isSafeInteger(startIndex) ||
+            startIndex <= 0 ||
+            startIndex >= listedCount ||
+            String(startIndex) !== nextToken) {
+            throw new SimBackupInvalidParameterValueException("NextToken is not a token this simulation issued");
+        }
+        return startIndex;
+    }
+    /** Issue a continuation token when more jobs remain. */
+    static tokenFor(nextIndex, listedCount) {
+        if (nextIndex >= listedCount) {
+            return undefined;
+        }
+        return String(nextIndex);
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { SimBackupJobOutput, SimBackupLifecycle, SimRecoveryPointCreator } from "../command/sim-backup-command.types.js";
+interface SimBackupJobProperties {
+    readonly accountId: string;
+    readonly id: 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 recoveryPointArn?: string | undefined;
+    readonly failure?: string | undefined;
+}
+/** The completed result of one simulated backup attempt. */
+export declare class SimBackupJob {
+    readonly id: string;
+    readonly vaultName: string;
+    readonly resourceArn: string;
+    readonly state: "COMPLETED" | "FAILED";
+    private readonly output;
+    constructor(properties: SimBackupJobProperties);
+    describe(): SimBackupJobOutput;
+}
+export {};

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

@@ -0,0 +1,10 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimBackupRecoveryPoint } from "../recovery-point/sim-backup-recovery-point.js";
+import { SimBackupJob } from "./sim-backup-job.js";
+import type { StartSimBackupJob } from "./sim-backup-job-input.js";
+/** Creates the stored record for a completed backup attempt. */
+export declare class SimBackupJobFactory {
+    private readonly scope;
+    constructor(scope: SimAwsAccountRegionScope);
+    make(input: StartSimBackupJob, recoveryPoint: SimBackupRecoveryPoint | undefined, failure: string | undefined): SimBackupJob;
+}

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

@@ -0,0 +1,24 @@
+import { randomUUID } from "node:crypto";
+import { SimBackupJob } from "./sim-backup-job.js";
+/** Creates the stored record for a completed backup attempt. */
+export class SimBackupJobFactory {
+    scope;
+    constructor(scope) {
+        this.scope = scope;
+    }
+    make(input, recoveryPoint, failure) {
+        return new SimBackupJob({
+            accountId: this.scope.accountId,
+            id: randomUUID(),
+            vaultName: input.vault.name,
+            vaultArn: input.vault.arn,
+            resourceArn: input.resourceArn,
+            iamRoleArn: input.iamRoleArn,
+            creationDate: input.at,
+            lifecycle: input.lifecycle,
+            createdBy: input.createdBy,
+            recoveryPointArn: recoveryPoint?.arn,
+            failure,
+        });
+    }
+}

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

@@ -0,0 +1,54 @@
+/** The completed result of one simulated backup attempt. */
+export class SimBackupJob {
+    id;
+    vaultName;
+    resourceArn;
+    state;
+    output;
+    constructor(properties) {
+        this.id = properties.id;
+        this.vaultName = properties.vaultName;
+        this.resourceArn = properties.resourceArn;
+        this.state = properties.failure === undefined ? "COMPLETED" : "FAILED";
+        this.output = {
+            AccountId: properties.accountId,
+            BackupJobId: properties.id,
+            BackupVaultName: properties.vaultName,
+            BackupVaultArn: properties.vaultArn,
+            RecoveryPointArn: properties.recoveryPointArn,
+            ResourceArn: properties.resourceArn,
+            CreationDate: new Date(properties.creationDate),
+            InitiationDate: new Date(properties.creationDate),
+            CompletionDate: new Date(properties.creationDate),
+            State: this.state,
+            StatusMessage: properties.failure,
+            PercentDone: this.state === "COMPLETED" ? "100.0" : "0.0",
+            IamRoleArn: properties.iamRoleArn,
+            CreatedBy: properties.createdBy === undefined
+                ? undefined
+                : { ...properties.createdBy },
+            RecoveryPointLifecycle: properties.lifecycle === undefined
+                ? undefined
+                : { ...properties.lifecycle },
+            IsParent: false,
+            MessageCategory: this.state === "COMPLETED" ? "SUCCESS" : "InvalidParameters",
+        };
+    }
+    describe() {
+        return {
+            ...this.output,
+            CreationDate: cloneDate(this.output.CreationDate),
+            InitiationDate: cloneDate(this.output.InitiationDate),
+            CompletionDate: cloneDate(this.output.CompletionDate),
+            CreatedBy: this.output.CreatedBy === undefined
+                ? undefined
+                : { ...this.output.CreatedBy },
+            RecoveryPointLifecycle: this.output.RecoveryPointLifecycle === undefined
+                ? undefined
+                : { ...this.output.RecoveryPointLifecycle },
+        };
+    }
+}
+function cloneDate(date) {
+    return date === undefined ? undefined : new Date(date);
+}

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

@@ -0,0 +1,18 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimBackupStore } from "../sim-backup-store.js";
+import type { SimBackupJob } from "./sim-backup-job.js";
+import type { StartSimBackupJob } from "./sim-backup-job-input.js";
+interface SimBackupJobsProperties {
+    readonly scope: SimAwsAccountRegionScope;
+    readonly store: SimBackupStore;
+}
+/** Completes backup attempts and records their jobs and recovery points. */
+export declare class SimBackupJobs {
+    private readonly store;
+    private readonly pointFactory;
+    private readonly jobFactory;
+    constructor(properties: SimBackupJobsProperties);
+    start(input: StartSimBackupJob): SimBackupJob;
+    private previous;
+}
+export {};

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

@@ -0,0 +1,33 @@
+import { SimBackupRecoveryPointFactory } from "../recovery-point/sim-backup-recovery-point.factory.js";
+import { SimBackupJobFactory } from "./sim-backup-job.factory.js";
+/** Completes backup attempts and records their jobs and recovery points. */
+export class SimBackupJobs {
+    store;
+    pointFactory;
+    jobFactory;
+    constructor(properties) {
+        this.store = properties.store;
+        this.pointFactory = new SimBackupRecoveryPointFactory(properties.scope);
+        this.jobFactory = new SimBackupJobFactory(properties.scope);
+    }
+    start(input) {
+        const previous = this.previous(input.idempotencyToken);
+        if (previous !== undefined) {
+            return previous;
+        }
+        const failure = input.vault.lifecycleRefusal(input.lifecycle);
+        const recoveryPoint = failure === undefined ? this.pointFactory.make(input) : undefined;
+        if (recoveryPoint !== undefined) {
+            input.vault.addRecoveryPoint(recoveryPoint);
+        }
+        const job = this.jobFactory.make(input, recoveryPoint, failure);
+        this.store.addJob(job, input.idempotencyToken);
+        return job;
+    }
+    previous(idempotencyKey) {
+        if (idempotencyKey === undefined) {
+            return undefined;
+        }
+        return this.store.jobByIdempotencyToken(idempotencyKey);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimBackupJobs } from "../job/sim-backup-jobs.js";
+import type { SimBackupStore } from "../sim-backup-store.js";
+import type { SimBackupPlan } from "./sim-backup-plan.js";
+interface SimBackupPlanSchedulesProperties {
+    readonly store: SimBackupStore;
+    readonly jobs: SimBackupJobs;
+    readonly background: BackgroundScheduler;
+}
+/** Runs backup plan rules when simulated time reaches their schedules. */
+export declare class SimBackupPlanSchedules {
+    private readonly store;
+    private readonly jobs;
+    private readonly background;
+    constructor(properties: SimBackupPlanSchedulesProperties);
+    arm(plan: SimBackupPlan): void;
+    private armAfter;
+    private fire;
+    private selectedResources;
+}
+export {};

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

@@ -0,0 +1,66 @@
+import { SimSchedule } from "../../../util/schedule/sim-schedule.js";
+import { backupScheduleDialect } from "./sim-backup-rule.js";
+/** Runs backup plan rules when simulated time reaches their schedules. */
+export class SimBackupPlanSchedules {
+    store;
+    jobs;
+    background;
+    constructor(properties) {
+        this.store = properties.store;
+        this.jobs = properties.jobs;
+        this.background = properties.background;
+    }
+    arm(plan) {
+        for (const rule of plan.rules) {
+            const schedule = SimSchedule.of(rule.ScheduleExpression, backupScheduleDialect);
+            this.armAfter(plan, rule, schedule, this.background.now());
+        }
+    }
+    armAfter(plan, rule, schedule, after) {
+        const due = schedule.nextAfter(after);
+        if (due === undefined) {
+            return;
+        }
+        this.background.scheduleAt(due, () => {
+            this.fire(plan, rule, schedule, due);
+            return Promise.resolve();
+        });
+    }
+    fire(plan, rule, schedule, due) {
+        if (this.store.plan(plan.id) !== plan) {
+            return;
+        }
+        const vault = this.store.vault(rule.TargetBackupVaultName);
+        if (vault !== undefined) {
+            for (const [resourceArn, iamRoleArn] of this.selectedResources(plan)) {
+                this.jobs.start({
+                    vault,
+                    resourceArn,
+                    iamRoleArn,
+                    at: due,
+                    lifecycle: rule.Lifecycle,
+                    createdBy: {
+                        BackupPlanId: plan.id,
+                        BackupPlanArn: plan.arn,
+                        BackupPlanName: plan.name,
+                        BackupPlanVersion: plan.versionId,
+                        BackupRuleId: rule.RuleId,
+                        BackupRuleName: rule.RuleName,
+                    },
+                });
+            }
+        }
+        this.armAfter(plan, rule, schedule, due);
+    }
+    selectedResources(plan) {
+        const selected = new Map();
+        for (const selection of this.store.selectionsForPlan(plan.id)) {
+            for (const resourceArn of selection.resources) {
+                if (!selected.has(resourceArn)) {
+                    selected.set(resourceArn, selection.iamRoleArn);
+                }
+            }
+        }
+        return selected;
+    }
+}

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

@@ -0,0 +1,22 @@
+import type { SimBackupPlanInput, SimBackupRule, SimGetBackupPlanCommandOutput } from "../command/sim-backup-command.types.js";
+interface SimBackupPlanProperties {
+    readonly id: string;
+    readonly arn: string;
+    readonly versionId: string;
+    readonly creationDate: Date;
+    readonly creatorRequestId?: string | undefined;
+    readonly plan: SimBackupPlanInput;
+}
+/** Stores one simulated AWS Backup plan. */
+export declare class SimBackupPlan {
+    readonly id: string;
+    readonly arn: string;
+    readonly versionId: string;
+    readonly creationDate: Date;
+    readonly creatorRequestId?: string | undefined;
+    readonly name: string;
+    readonly rules: readonly SimBackupRule[];
+    constructor(properties: SimBackupPlanProperties);
+    describe(): SimGetBackupPlanCommandOutput;
+}
+export {};

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"];