@kensio/yulin 1.21.26 → 1.21.28

package/dist/service/eventbridge/command/bus/sim-event-bridge-create-event-bus.d.ts

@@ -3,10 +3,12 @@ import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-regi
 import type { SimEventBusStore } from "../../bus/sim-event-bus-store.js";
 import type { SimEventBridgeRequestOptions } from "../sim-event-bridge-request-options.js";
 import type { SimEventBridgeBusAccess } from "./sim-event-bridge-bus-access.js";
+import type { SimEventBridgePartnerBus } from "./sim-event-bridge-partner-bus.js";
 import type { SimCreateEventBusCommand, SimCreateEventBusCommandOutput } from "./bus.command.js";
 interface SimEventBridgeCreateEventBusProperties {
     readonly buses: SimEventBusStore;
     readonly access: SimEventBridgeBusAccess;
+    readonly partnerBus: SimEventBridgePartnerBus;
     readonly accountRegionScope: SimAwsAccountRegionScope;
     readonly clock: BackgroundScheduler;
 }
@@ -16,15 +18,19 @@ interface SimEventBridgeCreateEventBusProperties {
  * Unlike SNS CreateTopic this is not idempotent: a name already taken is
  * refused rather than answered with the existing bus. `default` is among those
  * names, since that bus is always there.
+ *
+ * A request carrying an `EventSourceName` creates a partner event bus, which
+ * activates the partner event source of the same name.
  */
 export declare class SimEventBridgeCreateEventBus {
     private readonly buses;
     private readonly access;
+    private readonly partnerBus;
     private readonly accountRegionScope;
     private readonly clock;
     constructor(properties: SimEventBridgeCreateEventBusProperties);
     /**
-     * Create a custom event bus.
+     * Create a custom or partner event bus.
      *
      * The inputs are read before the name is looked for, so a request naming one
      * this simulation will not take is refused whether or not the name is free.

package/dist/service/eventbridge/command/bus/sim-event-bridge-create-event-bus.js

@@ -8,20 +8,25 @@ import { refuseUnsimulatedBusInput } from "./sim-event-bridge-unsimulated-bus-in
  * Unlike SNS CreateTopic this is not idempotent: a name already taken is
  * refused rather than answered with the existing bus. `default` is among those
  * names, since that bus is always there.
+ *
+ * A request carrying an `EventSourceName` creates a partner event bus, which
+ * activates the partner event source of the same name.
  */
 export class SimEventBridgeCreateEventBus {
     buses;
     access;
+    partnerBus;
     accountRegionScope;
     clock;
     constructor(properties) {
         this.buses = properties.buses;
         this.access = properties.access;
+        this.partnerBus = properties.partnerBus;
         this.accountRegionScope = properties.accountRegionScope;
         this.clock = properties.clock;
     }
     /**
-     * Create a custom event bus.
+     * Create a custom or partner event bus.
      *
      * The inputs are read before the name is looked for, so a request naming one
      * this simulation will not take is refused whether or not the name is free.
@@ -34,6 +39,7 @@ export class SimEventBridgeCreateEventBus {
         if (this.buses.find(name.value) !== undefined) {
             throw new SimEventBridgeResourceAlreadyExistsException(`Event bus ${name.value} already exists.`);
         }
+        this.partnerBus.check(name, input.EventSourceName);
         const bus = this.created(name, input.Description);
         return {
             $metadata: {},

package/dist/service/eventbridge/command/bus/sim-event-bridge-partner-bus.d.ts

@@ -0,0 +1,24 @@
+import type { SimEventBusName } from "../../bus/sim-event-bus-name.js";
+import type { SimPartnerEventSourceStore } from "../../source/sim-partner-event-source-store.js";
+/**
+ * Checks the name a bus is created under against the partner event source a
+ * CreateEventBus request names, if it names one.
+ *
+ * A partner event bus has to take the name of its source exactly, and only a
+ * partner event bus may carry a `/` in its name. The source has to exist
+ * already. A partner creates it from its own Account, and real EventBridge
+ * fails the request when there is no source to match.
+ */
+export declare class SimEventBridgePartnerBus {
+    private readonly sources;
+    constructor(sources: SimPartnerEventSourceStore);
+    /**
+     * Refuse a bus name that does not fit the source the request names, or a
+     * source that is not there.
+     */
+    check(name: SimEventBusName, eventSourceName: string | undefined): void;
+    /**
+     * Refuse a partner bus name on a request that names no partner source.
+     */
+    private refusePartnerName;
+}

package/dist/service/eventbridge/command/bus/sim-event-bridge-partner-bus.js

@@ -0,0 +1,44 @@
+import { SimEventBridgeValidationException } from "../../error/sim-event-bridge.error.js";
+import { SimPartnerEventSourceName } from "../../source/sim-partner-event-source-name.js";
+/**
+ * Checks the name a bus is created under against the partner event source a
+ * CreateEventBus request names, if it names one.
+ *
+ * A partner event bus has to take the name of its source exactly, and only a
+ * partner event bus may carry a `/` in its name. The source has to exist
+ * already. A partner creates it from its own Account, and real EventBridge
+ * fails the request when there is no source to match.
+ */
+export class SimEventBridgePartnerBus {
+    sources;
+    constructor(sources) {
+        this.sources = sources;
+    }
+    /**
+     * Refuse a bus name that does not fit the source the request names, or a
+     * source that is not there.
+     */
+    check(name, eventSourceName) {
+        if (eventSourceName === undefined) {
+            this.refusePartnerName(name);
+            return;
+        }
+        const sourceName = SimPartnerEventSourceName.of(eventSourceName, "EventSourceName");
+        if (sourceName.value !== name.value) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: Name Reason: a partner event bus takes the name ` +
+                `of its event source exactly, and '${name.value}' is not ` +
+                `'${sourceName.value}'.`);
+        }
+        this.sources.require(sourceName.value);
+    }
+    /**
+     * Refuse a partner bus name on a request that names no partner source.
+     */
+    refusePartnerName(name) {
+        if (name.isPartner) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: Name Reason: custom event bus names cannot ` +
+                `contain the '/' character. '${name.value}' is a partner event bus ` +
+                `name, and a partner event bus is created with an EventSourceName.`);
+        }
+    }
+}

package/dist/service/eventbridge/command/bus/sim-event-bridge-unsimulated-bus-input.js

@@ -7,11 +7,6 @@ const maximumDescriptionLength = 512;
  * What a CreateEventBus input carrying an unmodelled property is refused with.
  */
 const refusals = [
-    [
-        (input) => input.EventSourceName,
-        "Partner event buses are not simulated, so CreateEventBus refuses an " +
-            "EventSourceName rather than creating a bus no partner can reach",
-    ],
     [
         (input) => input.KmsKeyIdentifier,
         "Event bus encryption with a customer managed key is not simulated, so " +

package/dist/service/eventbridge/command/put-events/sim-event-bridge-authorized-entries.js

@@ -1,3 +1,4 @@
+import { SimEventBridgeValidationException } from "../../error/sim-event-bridge.error.js";
 /**
  * Resolve and authorize the bus every entry names, before any of them is
  * delivered.
@@ -10,6 +11,13 @@
 export function authorizedEntries(entries, access, options) {
     return entries.map((entry) => {
         const busName = access.requestedName(entry.EventBusName);
+        // PutEvents takes no `/` in a bus name or ARN, so it cannot name a partner
+        // event bus. Only the partner that owns the bus's event source sends
+        // events to it.
+        if (busName.isPartner) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: EventBusName Reason: '${busName.value}' is a ` +
+                `partner event bus, and only its partner sends events to it.`);
+        }
         access.authorizeName("events:PutEvents", busName, options);
         return { entry, busName: busName.value };
     });

package/dist/service/eventbridge/command/sim-event-bridge-command.types.d.ts

@@ -2,3 +2,4 @@ export type { SimCreateEventBusCommand, SimCreateEventBusCommandInput, SimCreate
 export type { SimPutEventsCommand, SimPutEventsCommandInput, SimPutEventsCommandOutput, SimPutEventsRequestEntry, SimPutEventsResultEntry, } from "./put-events/put-events.command.js";
 export type { SimDeleteRuleCommand, SimDeleteRuleCommandInput, SimDeleteRuleCommandOutput, SimDescribeRuleCommand, SimDescribeRuleCommandInput, SimDescribeRuleCommandOutput, SimDisableRuleCommand, SimDisableRuleCommandInput, SimDisableRuleCommandOutput, SimEnableRuleCommand, SimEnableRuleCommandInput, SimEnableRuleCommandOutput, SimListedRule, SimListRulesCommand, SimListRulesCommandInput, SimListRulesCommandOutput, SimPutRuleCommand, SimPutRuleCommandInput, SimPutRuleCommandOutput, SimTestEventPatternCommand, SimTestEventPatternCommandInput, SimTestEventPatternCommandOutput, } from "./rule/rule.command.js";
 export type { SimEventBridgeTarget, SimEventBridgeTargetFailure, SimListRuleNamesByTargetCommand, SimListRuleNamesByTargetCommandInput, SimListRuleNamesByTargetCommandOutput, SimListTargetsByRuleCommand, SimListTargetsByRuleCommandInput, SimListTargetsByRuleCommandOutput, SimPutTargetsCommand, SimPutTargetsCommandInput, SimPutTargetsCommandOutput, SimRemoveTargetsCommand, SimRemoveTargetsCommandInput, SimRemoveTargetsCommandOutput, } from "./target/target.command.js";
+export type { SimDescribeEventSourceCommand, SimDescribeEventSourceCommandInput, SimDescribeEventSourceCommandOutput, SimPutPartnerEventsCommand, SimPutPartnerEventsCommandInput, SimPutPartnerEventsCommandOutput, SimPutPartnerEventsRequestEntry, SimPutPartnerEventsResultEntry, } from "./source/source.command.js";

package/dist/service/eventbridge/command/sim-event-bridge-commands.d.ts

@@ -10,16 +10,20 @@ import { SimEventBridgeRuleSchedules } from "../schedule/sim-event-bridge-rule-s
 import { SimEventBridgeBusCommands } from "./bus/sim-event-bridge-bus-commands.js";
 import { SimEventBridgeCreateEventBus } from "./bus/sim-event-bridge-create-event-bus.js";
 import { SimEventBridgeDeleteEventBus } from "./bus/sim-event-bridge-delete-event-bus.js";
+import type { SimPartnerEventSourceStore } from "../source/sim-partner-event-source-store.js";
 import { SimEventBridgePutEvents } from "./put-events/sim-event-bridge-put-events.js";
 import { SimEventBridgePutRule } from "./rule/sim-event-bridge-put-rule.js";
 import { SimEventBridgeRuleCommands } from "./rule/sim-event-bridge-rule-commands.js";
 import { SimEventBridgeTestEventPattern } from "./rule/sim-event-bridge-test-event-pattern.js";
+import { SimEventBridgeDescribeEventSource } from "./source/sim-event-bridge-describe-event-source.js";
+import { SimEventBridgePutPartnerEvents } from "./source/sim-event-bridge-put-partner-events.js";
 import { SimEventBridgePutTargets } from "./target/sim-event-bridge-put-targets.js";
 import { SimEventBridgeTargetCommands } from "./target/sim-event-bridge-target-commands.js";
 interface SimEventBridgeCommandsProperties {
     readonly buses: SimEventBusStore;
     readonly rules: SimEventRuleStore;
     readonly targets: SimEventTargetStore;
+    readonly partnerSources: SimPartnerEventSourceStore;
     readonly deliveryTargets?: SimEventBridgeDeliveryTargets | undefined;
     readonly iam: SimIamInterServiceAuthZ;
     readonly background: BackgroundScheduler;
@@ -38,6 +42,8 @@ export declare class SimEventBridgeCommands {
     readonly busDeletion: SimEventBridgeDeleteEventBus;
     readonly buses: SimEventBridgeBusCommands;
     readonly putEvents: SimEventBridgePutEvents;
+    readonly putPartnerEvents: SimEventBridgePutPartnerEvents;
+    readonly eventSources: SimEventBridgeDescribeEventSource;
     readonly ruleCreation: SimEventBridgePutRule;
     readonly rules: SimEventBridgeRuleCommands;
     readonly patternTest: SimEventBridgeTestEventPattern;

package/dist/service/eventbridge/command/sim-event-bridge-commands.js

@@ -6,11 +6,14 @@ import { SimEventBridgeBusAccess } from "./bus/sim-event-bridge-bus-access.js";
 import { SimEventBridgeBusCommands } from "./bus/sim-event-bridge-bus-commands.js";
 import { SimEventBridgeCreateEventBus } from "./bus/sim-event-bridge-create-event-bus.js";
 import { SimEventBridgeDeleteEventBus } from "./bus/sim-event-bridge-delete-event-bus.js";
+import { SimEventBridgePartnerBus } from "./bus/sim-event-bridge-partner-bus.js";
 import { SimEventBridgePutEvents } from "./put-events/sim-event-bridge-put-events.js";
 import { SimEventBridgePutRule } from "./rule/sim-event-bridge-put-rule.js";
 import { SimEventBridgeRuleAccess } from "./rule/sim-event-bridge-rule-access.js";
 import { SimEventBridgeRuleCommands } from "./rule/sim-event-bridge-rule-commands.js";
 import { SimEventBridgeTestEventPattern } from "./rule/sim-event-bridge-test-event-pattern.js";
+import { SimEventBridgeDescribeEventSource } from "./source/sim-event-bridge-describe-event-source.js";
+import { SimEventBridgePutPartnerEvents } from "./source/sim-event-bridge-put-partner-events.js";
 import { SimEventBridgePutTargets } from "./target/sim-event-bridge-put-targets.js";
 import { SimEventBridgeTargetCommands } from "./target/sim-event-bridge-target-commands.js";
 /**
@@ -26,6 +29,8 @@ export class SimEventBridgeCommands {
     busDeletion;
     buses;
     putEvents;
+    putPartnerEvents;
+    eventSources;
     ruleCreation;
     rules;
     patternTest;
@@ -34,7 +39,7 @@ export class SimEventBridgeCommands {
     router;
     schedules;
     constructor(properties) {
-        const { buses, rules, targets, accountRegionScope, background } = properties;
+        const { buses, rules, targets, partnerSources, accountRegionScope, background, } = properties;
         const authorizer = new SimEventBridgeAuthorizer({ iam: properties.iam });
         const access = new SimEventBridgeBusAccess({
             buses,
@@ -50,6 +55,7 @@ export class SimEventBridgeCommands {
         this.busCreation = new SimEventBridgeCreateEventBus({
             buses,
             access,
+            partnerBus: new SimEventBridgePartnerBus(partnerSources),
             accountRegionScope,
             clock: background,
         });
@@ -80,6 +86,18 @@ export class SimEventBridgeCommands {
             clock: background,
             router: this.router,
         });
+        this.putPartnerEvents = new SimEventBridgePutPartnerEvents({
+            sources: partnerSources,
+            accountRegionScope,
+            clock: background,
+            router: this.router,
+        });
+        this.eventSources = new SimEventBridgeDescribeEventSource({
+            sources: partnerSources,
+            buses,
+            authorizer,
+            accountRegionScope,
+        });
         this.ruleCreation = new SimEventBridgePutRule({
             rules,
             access: ruleAccess,

package/dist/service/eventbridge/command/source/sim-event-bridge-describe-event-source.d.ts

@@ -0,0 +1,35 @@
+import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
+import type { SimEventBusStore } from "../../bus/sim-event-bus-store.js";
+import type { SimPartnerEventSourceStore } from "../../source/sim-partner-event-source-store.js";
+import type { SimEventBridgeAuthorizer } from "../authorize/sim-event-bridge-authorizer.js";
+import type { SimEventBridgeRequestOptions } from "../sim-event-bridge-request-options.js";
+import type { SimDescribeEventSourceCommand, SimDescribeEventSourceCommandOutput } from "./source.command.js";
+interface SimEventBridgeDescribeEventSourceProperties {
+    readonly sources: SimPartnerEventSourceStore;
+    readonly buses: SimEventBusStore;
+    readonly authorizer: SimEventBridgeAuthorizer;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+}
+/**
+ * The DescribeEventSource command.
+ *
+ * The state is `ACTIVE` while a partner event bus of the source's name exists,
+ * and `PENDING` otherwise. `ExpirationTime` is left out, because a pending
+ * source never expires here.
+ */
+export declare class SimEventBridgeDescribeEventSource {
+    private readonly sources;
+    private readonly buses;
+    private readonly authorizer;
+    private readonly accountRegionScope;
+    constructor(properties: SimEventBridgeDescribeEventSourceProperties);
+    /**
+     * Describe a partner event source shared with this Account and Region.
+     *
+     * The caller is authorized against the ARN the source would have before it
+     * is looked up, so a caller with no permission learns nothing about which
+     * sources exist.
+     */
+    handle(command: SimDescribeEventSourceCommand, options?: SimEventBridgeRequestOptions): SimDescribeEventSourceCommandOutput;
+}
+export {};

package/dist/service/eventbridge/command/source/sim-event-bridge-describe-event-source.js

@@ -0,0 +1,46 @@
+import { SimEventBridgeValidationException } from "../../error/sim-event-bridge.error.js";
+import { SimPartnerEventSourceName } from "../../source/sim-partner-event-source-name.js";
+import { partnerEventSourceArn } from "../../source/sim-partner-event-source.js";
+/**
+ * The DescribeEventSource command.
+ *
+ * The state is `ACTIVE` while a partner event bus of the source's name exists,
+ * and `PENDING` otherwise. `ExpirationTime` is left out, because a pending
+ * source never expires here.
+ */
+export class SimEventBridgeDescribeEventSource {
+    sources;
+    buses;
+    authorizer;
+    accountRegionScope;
+    constructor(properties) {
+        this.sources = properties.sources;
+        this.buses = properties.buses;
+        this.authorizer = properties.authorizer;
+        this.accountRegionScope = properties.accountRegionScope;
+    }
+    /**
+     * Describe a partner event source shared with this Account and Region.
+     *
+     * The caller is authorized against the ARN the source would have before it
+     * is looked up, so a caller with no permission learns nothing about which
+     * sources exist.
+     */
+    handle(command, options) {
+        const requested = command.input.Name;
+        if (requested === undefined) {
+            throw new SimEventBridgeValidationException("Invalid parameter: Name is required");
+        }
+        const name = SimPartnerEventSourceName.of(requested, "Name");
+        this.authorizer.authorizeEventSource("events:DescribeEventSource", partnerEventSourceArn(name, this.accountRegionScope), options);
+        const source = this.sources.require(name.value);
+        return {
+            $metadata: {},
+            Arn: source.arn,
+            CreatedBy: source.name.partner,
+            CreationTime: source.creationTime,
+            Name: source.name.value,
+            State: source.state(this.buses.find(source.name.value) !== undefined),
+        };
+    }
+}

package/dist/service/eventbridge/command/source/sim-event-bridge-put-partner-events.d.ts

@@ -0,0 +1,41 @@
+import type { BackgroundScheduler } from "../../../../util/background/background.js";
+import type { SimAwsAccountRegionScope } from "../../../aws/sim-aws-account-region-scope.js";
+import type { SimEventBridgeRouter } from "../../routing/sim-event-bridge-router.js";
+import type { SimPartnerEventSourceStore } from "../../source/sim-partner-event-source-store.js";
+import type { SimPutPartnerEventsCommand, SimPutPartnerEventsCommandOutput } from "./source.command.js";
+interface SimEventBridgePutPartnerEventsProperties {
+    readonly sources: SimPartnerEventSourceStore;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly clock: BackgroundScheduler;
+    readonly router: SimEventBridgeRouter;
+}
+/**
+ * Puts events onto partner event buses as their SaaS partner would.
+ *
+ * Each entry's `Source` names the partner event source it comes from, and the
+ * event goes to the bus of the same name. An event for a source with no bus is
+ * dropped. Real EventBridge documents that it keeps nothing a partner sends
+ * before the receiving Account creates the bus.
+ *
+ * Nothing is authorized. The partner sends from its own Account, which is
+ * outside the simulation, and the receiving Account's IAM has no say in it.
+ */
+export declare class SimEventBridgePutPartnerEvents {
+    private readonly sources;
+    private readonly clock;
+    private readonly router;
+    private readonly reader;
+    constructor(properties: SimEventBridgePutPartnerEventsProperties);
+    /**
+     * Put a partner's events onto the buses of their sources.
+     *
+     * Every `Source` is resolved before any event is put, so a request naming a
+     * source that was never registered changes nothing.
+     */
+    handle(command: SimPutPartnerEventsCommand): SimPutPartnerEventsCommandOutput;
+    /**
+     * Put one entry onto the bus its source names.
+     */
+    private put;
+}
+export {};

package/dist/service/eventbridge/command/source/sim-event-bridge-put-partner-events.js

@@ -0,0 +1,82 @@
+import { SimEventBridgeValidationException } from "../../error/sim-event-bridge.error.js";
+import { SimEventBridgeEntryFailure } from "../put-events/sim-event-bridge-entry-failure.js";
+import { SimEventBridgeEntryReader } from "../put-events/sim-event-bridge-entry-reader.js";
+import { simEventBridgeMaximumRequestBytes, simEventBridgeRequestSize, } from "../put-events/sim-event-bridge-entry-size.js";
+/**
+ * The most entries one PutPartnerEvents request may carry.
+ */
+const maximumEntries = 20;
+/**
+ * Puts events onto partner event buses as their SaaS partner would.
+ *
+ * Each entry's `Source` names the partner event source it comes from, and the
+ * event goes to the bus of the same name. An event for a source with no bus is
+ * dropped. Real EventBridge documents that it keeps nothing a partner sends
+ * before the receiving Account creates the bus.
+ *
+ * Nothing is authorized. The partner sends from its own Account, which is
+ * outside the simulation, and the receiving Account's IAM has no say in it.
+ */
+export class SimEventBridgePutPartnerEvents {
+    sources;
+    clock;
+    router;
+    reader;
+    constructor(properties) {
+        this.sources = properties.sources;
+        this.clock = properties.clock;
+        this.router = properties.router;
+        this.reader = new SimEventBridgeEntryReader({
+            accountRegionScope: properties.accountRegionScope,
+        });
+    }
+    /**
+     * Put a partner's events onto the buses of their sources.
+     *
+     * Every `Source` is resolved before any event is put, so a request naming a
+     * source that was never registered changes nothing.
+     */
+    handle(command) {
+        const entries = partnerRequestEntries(command.input.Entries ?? []);
+        for (const entry of entries) {
+            if (entry.Source !== undefined) {
+                this.sources.require(entry.Source);
+            }
+        }
+        const at = this.clock.now();
+        const results = entries.map((entry) => this.put(entry, at));
+        return {
+            $metadata: {},
+            Entries: results,
+            FailedEntryCount: results.filter((result) => result.ErrorCode !== undefined).length,
+        };
+    }
+    /**
+     * Put one entry onto the bus its source names.
+     */
+    put(entry, at) {
+        const read = this.reader.read(entry, at);
+        if (read instanceof SimEventBridgeEntryFailure) {
+            return read.toResultEntry();
+        }
+        this.router.deliver(read.source, read);
+        return { EventId: read.id };
+    }
+}
+/**
+ * Refuse a request carrying no entries, too many, or too many bytes.
+ */
+function partnerRequestEntries(entries) {
+    if (entries.length === 0 || entries.length > maximumEntries) {
+        throw new SimEventBridgeValidationException(`Invalid parameter: Entries Reason: a PutPartnerEvents request carries ` +
+            `between 1 and ${String(maximumEntries)} entries, and this one ` +
+            `carries ${String(entries.length)}`);
+    }
+    const size = simEventBridgeRequestSize(entries);
+    if (size > simEventBridgeMaximumRequestBytes) {
+        throw new SimEventBridgeValidationException(`Total size of the entries in the request is ${String(size)} bytes, ` +
+            `which is over the ${String(simEventBridgeMaximumRequestBytes)} byte ` +
+            `limit.`);
+    }
+    return entries;
+}

package/dist/service/eventbridge/command/source/source.command.d.ts

@@ -0,0 +1,59 @@
+import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
+/**
+ * Minimal structural sim EventBridge DescribeEventSource command.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/eventbridge/command/DescribeEventSourceCommand/
+ */
+export interface SimDescribeEventSourceCommand {
+    readonly input: SimDescribeEventSourceCommandInput;
+}
+export interface SimDescribeEventSourceCommandInput {
+    readonly Name?: string | undefined;
+}
+export interface SimDescribeEventSourceCommandOutput {
+    readonly Arn?: string | undefined;
+    readonly CreatedBy?: string | undefined;
+    readonly CreationTime?: Date | undefined;
+    readonly Name?: string | undefined;
+    readonly State?: string | undefined;
+    readonly $metadata: SimResponseMetadata;
+}
+/**
+ * One event as a partner's PutPartnerEvents request carries it.
+ *
+ * https://docs.aws.amazon.com/eventbridge/latest/APIReference/API_PutPartnerEventsRequestEntry.html
+ */
+export interface SimPutPartnerEventsRequestEntry {
+    readonly Source?: string | undefined;
+    readonly DetailType?: string | undefined;
+    readonly Detail?: string | undefined;
+    readonly Resources?: readonly string[] | undefined;
+    readonly Time?: Date | undefined;
+}
+/**
+ * One partner entry's result, which carries either an event id or a failure.
+ */
+export interface SimPutPartnerEventsResultEntry {
+    readonly EventId?: string | undefined;
+    readonly ErrorCode?: string | undefined;
+    readonly ErrorMessage?: string | undefined;
+}
+/**
+ * Minimal structural sim EventBridge PutPartnerEvents command.
+ *
+ * A SaaS partner sends this from its own Account. In a simulation it is a
+ * test acting as the partner, through `SimEventBridge.putPartnerEvents`.
+ *
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/eventbridge/command/PutPartnerEventsCommand/
+ */
+export interface SimPutPartnerEventsCommand {
+    readonly input: SimPutPartnerEventsCommandInput;
+}
+export interface SimPutPartnerEventsCommandInput {
+    readonly Entries?: readonly SimPutPartnerEventsRequestEntry[] | undefined;
+}
+export interface SimPutPartnerEventsCommandOutput {
+    readonly Entries?: readonly SimPutPartnerEventsResultEntry[] | undefined;
+    readonly FailedEntryCount?: number | undefined;
+    readonly $metadata: SimResponseMetadata;
+}

package/dist/service/eventbridge/command/source/source.command.js

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

package/dist/service/eventbridge/command/target/sim-event-bridge-target-commands.js

@@ -54,6 +54,8 @@ export class SimEventBridgeTargetCommands {
             Input: target.input,
             RoleArn: target.ecs?.roleArn,
             EcsParameters: target.ecs?.task.parameters.declared,
+            RetryPolicy: target.retryPolicy?.declared,
+            DeadLetterConfig: target.deadLetterConfig?.declared,
         }));
         const page = new SimEventBridgePage(listed, input.Limit, input.NextToken);
         return {

package/dist/service/eventbridge/command/target/sim-event-bridge-unsimulated-target-input.js

@@ -3,8 +3,8 @@ import { SimEventBridgeUnsimulatedInputException } from "../../error/sim-event-b
  * The properties that change what a target receives, or whether it receives
  * anything at all.
  *
- * Ignoring one would leave a test believing in a transformation, a retry or a
- * dead letter queue that never happened.
+ * Ignoring one would leave a test believing in a transformation that never
+ * happened.
  */
 const behaviourRefusals = [
     [
@@ -17,16 +17,6 @@ const behaviourRefusals = [
         "Target InputTransformer is not simulated, so PutTargets refuses one " +
             "rather than sending the untransformed event",
     ],
-    [
-        (target) => target.DeadLetterConfig,
-        "Target dead letter queues are not simulated, so PutTargets refuses a " +
-            "DeadLetterConfig rather than dropping undelivered events silently",
-    ],
-    [
-        (target) => target.RetryPolicy,
-        "Target retry policies are not simulated, so PutTargets refuses a " +
-            "RetryPolicy rather than delivering once and calling it retried",
-    ],
     [
         (target) => target.SqsParameters,
         "SqsParameters names a FIFO queue's message group, and FIFO queues are " +

package/dist/service/eventbridge/command/target/target.command.d.ts

@@ -1,11 +1,14 @@
 import type { SimResponseMetadata } from "../../../aws/metadata/response-metadata.type.js";
 import type { SimEcsTargetParametersType } from "../../../ecs/target/sim-ecs-target-parameters.js";
+import type { SimEventTargetDeadLetterConfigInput } from "../../target/sim-event-target-dead-letter-config.js";
+import type { SimEventTargetRetryPolicyInput } from "../../target/sim-event-target-retry-policy.js";
 /**
  * One target as a request carries it, and as ListTargetsByRule reports it.
  *
- * The properties beyond `Id`, `Arn`, `Input`, `RoleArn` and `EcsParameters`
- * are the ones real EventBridge takes and this simulation refuses, kept in the
- * shape so a request carrying one is recognised and named rather than ignored.
+ * The properties beyond `Id`, `Arn`, `Input`, `RoleArn`, `EcsParameters`,
+ * `DeadLetterConfig` and `RetryPolicy` are the ones real EventBridge takes and
+ * this simulation refuses. They are kept in the shape so a request carrying
+ * one is recognised and named.
  */
 export interface SimEventBridgeTarget {
     readonly Id?: string | undefined;
@@ -14,8 +17,8 @@ export interface SimEventBridgeTarget {
     readonly InputPath?: string | undefined;
     readonly InputTransformer?: object | undefined;
     readonly RoleArn?: string | undefined;
-    readonly DeadLetterConfig?: object | undefined;
-    readonly RetryPolicy?: object | undefined;
+    readonly DeadLetterConfig?: SimEventTargetDeadLetterConfigInput | undefined;
+    readonly RetryPolicy?: SimEventTargetRetryPolicyInput | undefined;
     readonly SqsParameters?: object | undefined;
     readonly KinesisParameters?: object | undefined;
     readonly EcsParameters?: SimEcsTargetParametersType | undefined;

package/dist/service/eventbridge/delivery/sim-aws-event-bridge-delivery-targets.d.ts

@@ -1,5 +1,5 @@
 import type { SimAws } from "../../aws/sim-aws.js";
-import type { SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
+import type { SimEventBridgeDeadLetterRequest, SimEventBridgeDeliveryRequest, SimEventBridgeDeliveryTargets } from "./sim-event-bridge-delivery.js";
 interface SimAwsEventBridgeDeliveryTargetsProperties {
     readonly simAws: SimAws;
 }
@@ -21,6 +21,11 @@ export declare class SimAwsEventBridgeDeliveryTargets implements SimEventBridgeD
      * Send one event to the target its ARN names.
      */
     deliver(request: SimEventBridgeDeliveryRequest): Promise<void>;
+    /**
+     * Send an event EventBridge gave up on to the dead-letter queue its target
+     * names, in the queue's own Account and Region.
+     */
+    deadLetter(request: SimEventBridgeDeadLetterRequest): Promise<void>;
     /**
      * Hand the delivery to the one destination that knows this service.
      */