@kensio/yulin 1.20.13 → 1.20.15

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

@@ -1,7 +1,8 @@
 /**
- * The CloudFormation Resource type simulated Scheduler creates.
+ * The CloudFormation Resource types simulated Scheduler creates.
  */
 export declare const schedulerScheduleResourceType = "AWS::Scheduler::Schedule";
+export declare const schedulerScheduleGroupResourceType = "AWS::Scheduler::ScheduleGroup";
 /**
  * Build the error a Resource of a simulated Scheduler type is refused with.
  *
@@ -10,7 +11,7 @@ export declare const schedulerScheduleResourceType = "AWS::Scheduler::Schedule";
  * the template asked for it is the wrong answer: the Stack would look deployed
  * while nothing ever fired. So a refusal here says the Resource is invalid.
  */
-export declare function simCfnSchedulerResourceError(logicalId: string, reason: string, cause?: unknown): Error;
+export declare function simCfnSchedulerResourceError(resourceType: string, logicalId: string, reason: string, cause?: unknown): Error;
 /**
  * Run the simulated Scheduler commands one Resource is made of, naming the
  * Resource in whatever they refuse.
@@ -20,4 +21,14 @@ export declare function simCfnSchedulerResourceError(logicalId: string, reason:
  * again in the CloudFormation layer. Only Scheduler's own errors are renamed,
  * so a refusal the CloudFormation layer decided keeps its own wording.
  */
-export declare function simCfnSchedulerResourceCreation<T>(logicalId: string, create: () => Promise<T>): Promise<T>;
+export declare function simCfnSchedulerResourceCreation<T>(resourceType: string, logicalId: string, create: () => Promise<T>): Promise<T>;
+/**
+ * Remove the resource one Resource created, leaving one that has already gone.
+ *
+ * Real CloudFormation treats deleting a Resource that has already gone as
+ * done rather than as a failure, and a Scheduler teardown reaches that case. A
+ * schedule group takes its schedules with it. A schedule whose template named
+ * its group as a string rather than by `Ref` declares no dependency on it, and
+ * may find itself already deleted by the time its own turn comes.
+ */
+export declare function simCfnSchedulerResourceDeletion(remove: () => Promise<void>): Promise<void>;

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

@@ -1,8 +1,9 @@
-import { SimSchedulerError } from "../error/sim-scheduler.error.js";
+import { SimSchedulerError, SimSchedulerResourceNotFoundException, } from "../error/sim-scheduler.error.js";
 /**
- * The CloudFormation Resource type simulated Scheduler creates.
+ * The CloudFormation Resource types simulated Scheduler creates.
  */
 export const schedulerScheduleResourceType = "AWS::Scheduler::Schedule";
+export const schedulerScheduleGroupResourceType = "AWS::Scheduler::ScheduleGroup";
 /**
  * Build the error a Resource of a simulated Scheduler type is refused with.
  *
@@ -11,8 +12,10 @@ export const schedulerScheduleResourceType = "AWS::Scheduler::Schedule";
  * the template asked for it is the wrong answer: the Stack would look deployed
  * while nothing ever fired. So a refusal here says the Resource is invalid.
  */
-export function simCfnSchedulerResourceError(logicalId, reason, cause) {
-    return new Error(`Invalid ${schedulerScheduleResourceType} Resource ${logicalId}: ${reason}`, { cause });
+export function simCfnSchedulerResourceError(resourceType, logicalId, reason, cause) {
+    return new Error(`Invalid ${resourceType} Resource ${logicalId}: ${reason}`, {
+        cause,
+    });
 }
 /**
  * Run the simulated Scheduler commands one Resource is made of, naming the
@@ -23,14 +26,33 @@ export function simCfnSchedulerResourceError(logicalId, reason, cause) {
  * again in the CloudFormation layer. Only Scheduler's own errors are renamed,
  * so a refusal the CloudFormation layer decided keeps its own wording.
  */
-export async function simCfnSchedulerResourceCreation(logicalId, create) {
+export async function simCfnSchedulerResourceCreation(resourceType, logicalId, create) {
     try {
         return await create();
     }
     catch (error) {
         if (error instanceof SimSchedulerError) {
-            throw simCfnSchedulerResourceError(logicalId, error.message, error);
+            throw simCfnSchedulerResourceError(resourceType, logicalId, error.message, error);
         }
         throw error;
     }
 }
+/**
+ * Remove the resource one Resource created, leaving one that has already gone.
+ *
+ * Real CloudFormation treats deleting a Resource that has already gone as
+ * done rather than as a failure, and a Scheduler teardown reaches that case. A
+ * schedule group takes its schedules with it. A schedule whose template named
+ * its group as a string rather than by `Ref` declares no dependency on it, and
+ * may find itself already deleted by the time its own turn comes.
+ */
+export async function simCfnSchedulerResourceDeletion(remove) {
+    try {
+        await remove();
+    }
+    catch (error) {
+        if (!(error instanceof SimSchedulerResourceNotFoundException)) {
+            throw error;
+        }
+    }
+}

package/dist/service/scheduler/cfn/sim-cfn-scheduler-resource-lookup.d.ts

@@ -1,6 +1,10 @@
 import type { SimSchedulerScheduleInput } from "../command/schedule/schedule.command.js";
 import type { SimSchedulerSchedule } from "../schedule/sim-scheduler-schedule.js";
 import type { SimScheduler } from "../sim-scheduler.js";
+/**
+ * The `AWS::Scheduler::*` Resource types this service creates.
+ */
+export type SimSchedulerCfnResourceTypeName = "Schedule" | "ScheduleGroup";
 /**
  * Find the schedule a Resource just created, in whichever group it went into.
  *
@@ -10,9 +14,11 @@ import type { SimScheduler } from "../sim-scheduler.js";
  */
 export declare function createdSchedule(scheduler: SimScheduler, input: SimSchedulerScheduleInput): SimSchedulerSchedule | undefined;
 /**
- * Refuse a Resource type this service does not create.
+ * Read the Resource type a request names, refusing one this service does not
+ * create.
  *
- * Schedule groups are the other `AWS::Scheduler::*` type, and are reported as
- * unsupported rather than quietly treated as deployed.
+ * A schedule and a schedule group are the whole of `AWS::Scheduler::*`, so
+ * anything else is a type AWS has added since, reported as unsupported rather
+ * than quietly treated as deployed.
  */
-export declare function refuseUnknownType(resourceTypeName: string): void;
+export declare function schedulerResourceTypeName(resourceTypeName: string): SimSchedulerCfnResourceTypeName;

package/dist/service/scheduler/cfn/sim-cfn-scheduler-resource-lookup.js

@@ -15,13 +15,16 @@ export function createdSchedule(scheduler, input) {
         : scheduler.findSchedule(name, input.GroupName);
 }
 /**
- * Refuse a Resource type this service does not create.
+ * Read the Resource type a request names, refusing one this service does not
+ * create.
  *
- * Schedule groups are the other `AWS::Scheduler::*` type, and are reported as
- * unsupported rather than quietly treated as deployed.
+ * A schedule and a schedule group are the whole of `AWS::Scheduler::*`, so
+ * anything else is a type AWS has added since, reported as unsupported rather
+ * than quietly treated as deployed.
  */
-export function refuseUnknownType(resourceTypeName) {
-    if (resourceTypeName !== "Schedule") {
-        throw new Error(`Unsupported sim Scheduler CloudFormation Resource ${resourceTypeName}`);
+export function schedulerResourceTypeName(resourceTypeName) {
+    if (resourceTypeName === "Schedule" || resourceTypeName === "ScheduleGroup") {
+        return resourceTypeName;
     }
+    throw new Error(`Unsupported sim Scheduler CloudFormation Resource ${resourceTypeName}`);
 }

package/dist/service/scheduler/cfn/sim-scheduler-cfn-resource-factory.d.ts

@@ -8,22 +8,20 @@ interface SimSchedulerCfnResourceFactoryProperties {
 /**
  * CloudFormation Resource factory for simulated Scheduler resources.
  *
- * There is one type, and the schedule goes through the ordinary CreateSchedule
- * command rather than being constructed directly, so a schedule a template
- * deployed is the same thing an SDK caller would have got, down to the
- * refusals.
+ * Two types, a schedule and the group it goes in, both created through the
+ * ordinary Scheduler commands rather than constructed directly.
  */
 export declare class SimSchedulerCfnResourceFactory implements SimCfnServiceResourceFactory {
-    private readonly scheduler;
+    private readonly scheduleCreator;
+    private readonly groupCreator;
     constructor(properties: SimSchedulerCfnResourceFactoryProperties);
     /**
-     * Create a simulated schedule from a CloudFormation Resource.
+     * Create a simulated Scheduler resource from a CloudFormation Resource.
      */
     create(resourceTypeName: string, resource: SimCfnResource, context: SimCloudFormationResourceCreateContext): Promise<object | undefined>;
     /**
-     * Delete the schedule a Resource created.
+     * Delete the resource a Resource created.
      */
     delete(resourceTypeName: string, resource: SimCfnResource, context: SimCloudFormationResourceDeleteContext): Promise<void>;
-    private read;
 }
 export {};

package/dist/service/scheduler/cfn/sim-scheduler-cfn-resource-factory.js

@@ -1,49 +1,36 @@
-import { assertDefined } from "../../../util/type-guard/defined.js";
-import { createdSchedule, refuseUnknownType, } from "./sim-cfn-scheduler-resource-lookup.js";
-import { SimCfnScheduleProperties } from "./sim-cfn-schedule-properties.js";
-import { simCfnSchedulerResourceCreation } from "./sim-cfn-scheduler-resource-error.js";
+import { SimCfnScheduleCreator } from "./sim-cfn-schedule-creator.js";
+import { SimCfnScheduleGroupCreator } from "./sim-cfn-schedule-group-creator.js";
+import { schedulerResourceTypeName } from "./sim-cfn-scheduler-resource-lookup.js";
 /**
  * CloudFormation Resource factory for simulated Scheduler resources.
  *
- * There is one type, and the schedule goes through the ordinary CreateSchedule
- * command rather than being constructed directly, so a schedule a template
- * deployed is the same thing an SDK caller would have got, down to the
- * refusals.
+ * Two types, a schedule and the group it goes in, both created through the
+ * ordinary Scheduler commands rather than constructed directly.
  */
 export class SimSchedulerCfnResourceFactory {
-    scheduler;
+    scheduleCreator;
+    groupCreator;
     constructor(properties) {
-        this.scheduler = properties.scheduler;
+        this.scheduleCreator = new SimCfnScheduleCreator(properties);
+        this.groupCreator = new SimCfnScheduleGroupCreator(properties);
     }
     /**
-     * Create a simulated schedule from a CloudFormation Resource.
+     * Create a simulated Scheduler resource from a CloudFormation Resource.
      */
     async create(resourceTypeName, resource, context) {
-        refuseUnknownType(resourceTypeName);
-        const properties = this.read(resource, context.resolvedProperties ?? resource.properties);
-        const input = properties.scheduleInput();
-        return await simCfnSchedulerResourceCreation(resource.logicalId, async () => {
-            await this.scheduler.createSchedule({ input });
-            const schedule = createdSchedule(this.scheduler, input);
-            assertDefined(schedule, `sim Scheduler schedule ${String(input.Name)} after ` +
-                `CloudFormation creation`);
-            return schedule;
-        });
+        if (schedulerResourceTypeName(resourceTypeName) === "ScheduleGroup") {
+            return await this.groupCreator.create(resource, context);
+        }
+        return await this.scheduleCreator.create(resource, context);
     }
     /**
-     * Delete the schedule a Resource created.
+     * Delete the resource a Resource created.
      */
     async delete(resourceTypeName, resource, context) {
-        refuseUnknownType(resourceTypeName);
-        const properties = this.read(resource, context.resolvedProperties ?? resource.properties);
-        await this.scheduler.deleteSchedule({
-            input: {
-                Name: properties.name(),
-                GroupName: properties.scheduleInput().GroupName,
-            },
-        });
-    }
-    read(resource, properties) {
-        return new SimCfnScheduleProperties({ resource, properties });
+        if (schedulerResourceTypeName(resourceTypeName) === "ScheduleGroup") {
+            await this.groupCreator.delete(resource, context);
+            return;
+        }
+        await this.scheduleCreator.delete(resource, context);
     }
 }

package/dist/service/scheduler/command/authorize/sim-scheduler-authorizer.d.ts

@@ -10,7 +10,8 @@ interface SimSchedulerAuthorizerProperties {
  * The resource is the schedule ARN, which carries its group:
  * `arn:aws:scheduler:<region>:<account>:schedule/<group>/<name>`. A policy
  * written without the group in it matches nothing here, as it matches nothing
- * on real AWS.
+ * on real AWS. A group command authorizes against the group's own ARN, which
+ * is a different resource path: `schedule-group/<name>`.
  *
  * This is the caller's own authorization to manage schedules, and is a separate
  * question from whether a schedule's execution role may invoke its target. The
@@ -22,16 +23,16 @@ export declare class SimSchedulerAuthorizer {
     private readonly callerIdentifier;
     constructor(properties: SimSchedulerAuthorizerProperties);
     /**
-     * Ensure the caller may perform an action on a schedule, named by its ARN.
+     * Ensure the caller may perform an action on a resource, named by its ARN.
      *
-     * The schedule need not exist: `CreateSchedule` authorizes against the ARN
-     * the schedule is about to have.
+     * The resource need not exist: `CreateSchedule` authorizes against the ARN
+     * the schedule is about to have, and `CreateScheduleGroup` against the
+     * group's.
      */
-    authorizeSchedule(action: string, scheduleArn: string, options?: SimSchedulerRequestOptions): SimAwsResolvedCaller;
+    authorizeResource(action: string, resource: string, options?: SimSchedulerRequestOptions): SimAwsResolvedCaller;
     /**
-     * Ensure the caller may perform an action naming no particular schedule.
+     * Ensure the caller may perform an action naming no particular resource.
      */
-    authorizeAnySchedule(action: string, options?: SimSchedulerRequestOptions): SimAwsResolvedCaller;
-    private authorizeResource;
+    authorizeAnyResource(action: string, options?: SimSchedulerRequestOptions): SimAwsResolvedCaller;
 }
 export {};

package/dist/service/scheduler/command/authorize/sim-scheduler-authorizer.js

@@ -3,8 +3,8 @@ import { SimSchedulerAccessDeniedException } from "../../error/sim-scheduler.err
 /**
  * The resource an action with no resource type authorizes against.
  *
- * `ListSchedules` names no schedule, so IAM evaluates it against `*` and only a
- * policy whose Resource is `*` allows it.
+ * `ListSchedules` and `ListScheduleGroups` name nothing, so IAM evaluates them
+ * against `*` and only a policy whose Resource is `*` allows them.
  */
 const noResource = "*";
 /**
@@ -13,7 +13,8 @@ const noResource = "*";
  * The resource is the schedule ARN, which carries its group:
  * `arn:aws:scheduler:<region>:<account>:schedule/<group>/<name>`. A policy
  * written without the group in it matches nothing here, as it matches nothing
- * on real AWS.
+ * on real AWS. A group command authorizes against the group's own ARN, which
+ * is a different resource path: `schedule-group/<name>`.
  *
  * This is the caller's own authorization to manage schedules, and is a separate
  * question from whether a schedule's execution role may invoke its target. The
@@ -27,20 +28,12 @@ export class SimSchedulerAuthorizer {
         this.iam = properties.iam;
     }
     /**
-     * Ensure the caller may perform an action on a schedule, named by its ARN.
+     * Ensure the caller may perform an action on a resource, named by its ARN.
      *
-     * The schedule need not exist: `CreateSchedule` authorizes against the ARN
-     * the schedule is about to have.
+     * The resource need not exist: `CreateSchedule` authorizes against the ARN
+     * the schedule is about to have, and `CreateScheduleGroup` against the
+     * group's.
      */
-    authorizeSchedule(action, scheduleArn, options) {
-        return this.authorizeResource(action, scheduleArn, options);
-    }
-    /**
-     * Ensure the caller may perform an action naming no particular schedule.
-     */
-    authorizeAnySchedule(action, options) {
-        return this.authorizeResource(action, noResource, options);
-    }
     authorizeResource(action, resource, options) {
         const decision = this.iam.authorize({
             action,
@@ -54,4 +47,10 @@ export class SimSchedulerAuthorizer {
         }
         return decision.caller;
     }
+    /**
+     * Ensure the caller may perform an action naming no particular resource.
+     */
+    authorizeAnyResource(action, options) {
+        return this.authorizeResource(action, noResource, options);
+    }
 }

package/dist/service/scheduler/command/group/group.command.d.ts

@@ -0,0 +1,90 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+/**
+ * One tag a request asks to put on a schedule group.
+ *
+ * Read only so the group commands can refuse them. Nothing here stores a tag,
+ * and a group carrying one it never got would be worse than the refusal.
+ */
+export interface SimSchedulerTag {
+    readonly Key?: string | undefined;
+    readonly Value?: string | undefined;
+}
+/**
+ * Minimal structural sim Scheduler CreateScheduleGroup command.
+ *
+ * https://docs.aws.amazon.com/scheduler/latest/APIReference/API_CreateScheduleGroup.html
+ */
+export interface SimCreateScheduleGroupCommand {
+    readonly input: SimCreateScheduleGroupCommandInput;
+}
+export interface SimCreateScheduleGroupCommandInput {
+    readonly Name?: string | undefined;
+    readonly Tags?: readonly SimSchedulerTag[] | undefined;
+    readonly ClientToken?: string | undefined;
+}
+export interface SimCreateScheduleGroupCommandOutput {
+    readonly ScheduleGroupArn?: string | undefined;
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * Minimal structural sim Scheduler GetScheduleGroup command.
+ *
+ * https://docs.aws.amazon.com/scheduler/latest/APIReference/API_GetScheduleGroup.html
+ */
+export interface SimGetScheduleGroupCommand {
+    readonly input: SimGetScheduleGroupCommandInput;
+}
+export interface SimGetScheduleGroupCommandInput {
+    readonly Name?: string | undefined;
+}
+export interface SimGetScheduleGroupCommandOutput {
+    readonly Arn?: string | undefined;
+    readonly Name?: string | undefined;
+    readonly State?: string | undefined;
+    readonly CreationDate?: Date | undefined;
+    readonly LastModificationDate?: Date | undefined;
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * Minimal structural sim Scheduler DeleteScheduleGroup command.
+ *
+ * https://docs.aws.amazon.com/scheduler/latest/APIReference/API_DeleteScheduleGroup.html
+ */
+export interface SimDeleteScheduleGroupCommand {
+    readonly input: SimDeleteScheduleGroupCommandInput;
+}
+export interface SimDeleteScheduleGroupCommandInput {
+    readonly Name?: string | undefined;
+    readonly ClientToken?: string | undefined;
+}
+export interface SimDeleteScheduleGroupCommandOutput {
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * One schedule group as a listing reports it, which is all of it.
+ */
+export interface SimSchedulerListedScheduleGroup {
+    readonly Arn: string;
+    readonly Name: string;
+    readonly State: string;
+    readonly CreationDate: Date;
+    readonly LastModificationDate: Date;
+}
+/**
+ * Minimal structural sim Scheduler ListScheduleGroups command.
+ *
+ * https://docs.aws.amazon.com/scheduler/latest/APIReference/API_ListScheduleGroups.html
+ */
+export interface SimListScheduleGroupsCommand {
+    readonly input: SimListScheduleGroupsCommandInput;
+}
+export interface SimListScheduleGroupsCommandInput {
+    readonly NamePrefix?: string | undefined;
+    readonly MaxResults?: number | undefined;
+    readonly NextToken?: string | undefined;
+}
+export interface SimListScheduleGroupsCommandOutput {
+    readonly ScheduleGroups?: readonly SimSchedulerListedScheduleGroup[] | undefined;
+    readonly NextToken?: string | undefined;
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/scheduler/command/group/group.command.js

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

package/dist/service/scheduler/command/group/sim-scheduler-described-group.d.ts

@@ -0,0 +1,15 @@
+import type { SimSchedulerScheduleGroup } from "../../group/sim-scheduler-schedule-group.js";
+import type { SimGetScheduleGroupCommandOutput, SimSchedulerListedScheduleGroup } from "./group.command.js";
+/**
+ * One group as `GetScheduleGroup` reports it.
+ */
+export declare function describedScheduleGroup(group: SimSchedulerScheduleGroup): Omit<SimGetScheduleGroupCommandOutput, "$metadata">;
+/**
+ * One group as a listing reports it.
+ *
+ * A group has nothing a describe carries and a listing does not, unlike a
+ * schedule, so these two agree on everything. They are written apart anyway
+ * because the AWS shapes are separate and only one of them has required
+ * fields.
+ */
+export declare function listedScheduleGroup(group: SimSchedulerScheduleGroup): SimSchedulerListedScheduleGroup;

package/dist/service/scheduler/command/group/sim-scheduler-described-group.js

@@ -0,0 +1,29 @@
+/**
+ * One group as `GetScheduleGroup` reports it.
+ */
+export function describedScheduleGroup(group) {
+    return {
+        Arn: group.arn,
+        Name: group.name,
+        State: group.state,
+        CreationDate: group.creationDate,
+        LastModificationDate: group.lastModificationDate,
+    };
+}
+/**
+ * One group as a listing reports it.
+ *
+ * A group has nothing a describe carries and a listing does not, unlike a
+ * schedule, so these two agree on everything. They are written apart anyway
+ * because the AWS shapes are separate and only one of them has required
+ * fields.
+ */
+export function listedScheduleGroup(group) {
+    return {
+        Arn: group.arn,
+        Name: group.name,
+        State: group.state,
+        CreationDate: group.creationDate,
+        LastModificationDate: group.lastModificationDate,
+    };
+}

package/dist/service/scheduler/command/group/sim-scheduler-group-access.d.ts

@@ -0,0 +1,57 @@
+import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
+import type { SimSchedulerScheduleGroup } from "../../group/sim-scheduler-schedule-group.js";
+import type { SimSchedulerScheduleGroupStore } from "../../group/sim-scheduler-schedule-group-store.js";
+import type { SimSchedulerAuthorizer } from "../authorize/sim-scheduler-authorizer.js";
+import type { SimSchedulerRequestOptions } from "../sim-scheduler-request-options.js";
+interface SimSchedulerGroupAccessProperties {
+    readonly groups: SimSchedulerScheduleGroupStore;
+    readonly authorizer: SimSchedulerAuthorizer;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+}
+/**
+ * How a request reaches the schedule group it names.
+ *
+ * The same shape as `SimSchedulerScheduleAccess`, and for the same reason. The
+ * caller is authorized before the group is looked up, and a caller with no
+ * permission is refused whether or not the group is there.
+ */
+export declare class SimSchedulerGroupAccess {
+    private readonly groups;
+    private readonly authorizer;
+    private readonly accountRegionScope;
+    constructor(properties: SimSchedulerGroupAccessProperties);
+    /**
+     * Read the group name a request names, and authorize the action on it.
+     *
+     * The group need not exist: `CreateScheduleGroup` authorizes against the ARN
+     * the group is about to have.
+     */
+    authorized(action: string, name: string | undefined, options?: SimSchedulerRequestOptions): string;
+    /**
+     * Resolve the group a request names, authorizing the action first.
+     */
+    require(action: string, name: string | undefined, options?: SimSchedulerRequestOptions): SimSchedulerScheduleGroup;
+    /**
+     * Resolve the group a request wants deleted, which `default` is never one
+     * of.
+     *
+     * AWS leaves the answer for the `default` group undocumented, and a
+     * simulation that let it go would have no way of getting it back. It comes
+     * with the Account rather than being created, and every request naming no
+     * group wants it.
+     */
+    requireDeletable(action: string, name: string | undefined, options?: SimSchedulerRequestOptions): SimSchedulerScheduleGroup;
+    /**
+     * Let a listing through, which names no group.
+     *
+     * `ListScheduleGroups` authorizes against every group in the Account rather
+     * than against each one it is about to report, and does not filter the
+     * listing by what the caller can reach.
+     */
+    authorizeListing(action: string, options?: SimSchedulerRequestOptions): void;
+    /**
+     * The ARN a group of this name has, or would have.
+     */
+    private arnFor;
+}
+export {};

package/dist/service/scheduler/command/group/sim-scheduler-group-access.js

@@ -0,0 +1,70 @@
+import { schedulerScheduleGroupArn } from "../../group/sim-scheduler-schedule-group-arn.js";
+import { SimSchedulerValidationException } from "../../error/sim-scheduler.error.js";
+import { defaultScheduleGroupName, requiredScheduleGroupName, } from "../../schedule/sim-scheduler-schedule-name.js";
+/**
+ * How a request reaches the schedule group it names.
+ *
+ * The same shape as `SimSchedulerScheduleAccess`, and for the same reason. The
+ * caller is authorized before the group is looked up, and a caller with no
+ * permission is refused whether or not the group is there.
+ */
+export class SimSchedulerGroupAccess {
+    groups;
+    authorizer;
+    accountRegionScope;
+    constructor(properties) {
+        this.groups = properties.groups;
+        this.authorizer = properties.authorizer;
+        this.accountRegionScope = properties.accountRegionScope;
+    }
+    /**
+     * Read the group name a request names, and authorize the action on it.
+     *
+     * The group need not exist: `CreateScheduleGroup` authorizes against the ARN
+     * the group is about to have.
+     */
+    authorized(action, name, options) {
+        const groupName = requiredScheduleGroupName(name);
+        this.authorizer.authorizeResource(action, this.arnFor(groupName), options);
+        return groupName;
+    }
+    /**
+     * Resolve the group a request names, authorizing the action first.
+     */
+    require(action, name, options) {
+        return this.groups.require(this.authorized(action, name, options));
+    }
+    /**
+     * Resolve the group a request wants deleted, which `default` is never one
+     * of.
+     *
+     * AWS leaves the answer for the `default` group undocumented, and a
+     * simulation that let it go would have no way of getting it back. It comes
+     * with the Account rather than being created, and every request naming no
+     * group wants it.
+     */
+    requireDeletable(action, name, options) {
+        const groupName = this.authorized(action, name, options);
+        if (groupName === defaultScheduleGroupName) {
+            throw new SimSchedulerValidationException(`The ${defaultScheduleGroupName} schedule group comes with the ` +
+                `Account and cannot be deleted.`);
+        }
+        return this.groups.require(groupName);
+    }
+    /**
+     * Let a listing through, which names no group.
+     *
+     * `ListScheduleGroups` authorizes against every group in the Account rather
+     * than against each one it is about to report, and does not filter the
+     * listing by what the caller can reach.
+     */
+    authorizeListing(action, options) {
+        this.authorizer.authorizeAnyResource(action, options);
+    }
+    /**
+     * The ARN a group of this name has, or would have.
+     */
+    arnFor(groupName) {
+        return schedulerScheduleGroupArn(groupName, this.accountRegionScope);
+    }
+}

package/dist/service/scheduler/command/group/sim-scheduler-group-commands.d.ts

@@ -0,0 +1,46 @@
+import type { SimSchedulerScheduleGroupStore } from "../../group/sim-scheduler-schedule-group-store.js";
+import type { SimSchedulerScheduleStore } from "../../schedule/sim-scheduler-schedule-store.js";
+import type { SimSchedulerRequestOptions } from "../sim-scheduler-request-options.js";
+import type { SimSchedulerGroupAccess } from "./sim-scheduler-group-access.js";
+import type { SimCreateScheduleGroupCommand, SimCreateScheduleGroupCommandOutput, SimDeleteScheduleGroupCommand, SimDeleteScheduleGroupCommandOutput, SimGetScheduleGroupCommand, SimGetScheduleGroupCommandOutput, SimListScheduleGroupsCommand, SimListScheduleGroupsCommandOutput } from "./group.command.js";
+interface SimSchedulerGroupCommandsProperties {
+    readonly groups: SimSchedulerScheduleGroupStore;
+    readonly schedules: SimSchedulerScheduleStore;
+    readonly access: SimSchedulerGroupAccess;
+}
+/**
+ * The commands that manage schedule groups.
+ *
+ * All four in one handler, unlike schedules, where creating and updating are
+ * their own. A group is a name. There is no request to read into a resource,
+ * and no update at all, since `Name` is the only thing a group has and AWS
+ * replaces the group to change it.
+ */
+export declare class SimSchedulerGroupCommands {
+    private readonly groups;
+    private readonly schedules;
+    private readonly access;
+    constructor(properties: SimSchedulerGroupCommandsProperties);
+    /**
+     * Create a schedule group.
+     */
+    createScheduleGroup(command: SimCreateScheduleGroupCommand, options?: SimSchedulerRequestOptions): SimCreateScheduleGroupCommandOutput;
+    /**
+     * Describe a schedule group.
+     */
+    getScheduleGroup(command: SimGetScheduleGroupCommand, options?: SimSchedulerRequestOptions): SimGetScheduleGroupCommandOutput;
+    /**
+     * Delete a schedule group, and the schedules in it.
+     *
+     * AWS deletes the schedules with the group rather than refusing a group that
+     * still holds some, and leaves the group in a `DELETING` state until they
+     * have gone. Here they go in the same call, so nothing is ever seen in that
+     * state.
+     */
+    deleteScheduleGroup(command: SimDeleteScheduleGroupCommand, options?: SimSchedulerRequestOptions): SimDeleteScheduleGroupCommandOutput;
+    /**
+     * List the schedule groups of this scope, in creation order.
+     */
+    listScheduleGroups(command: SimListScheduleGroupsCommand, options?: SimSchedulerRequestOptions): SimListScheduleGroupsCommandOutput;
+}
+export {};