@kensio/yulin 1.21.25 → 1.21.27

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

@@ -1,6 +1,7 @@
+import { SimEventBridgeDeliveryAttempt } from "./sim-event-bridge-delivery-attempt.js";
 import { SimEventBridgeDeliveryFailures } from "./sim-event-bridge-delivery-failures.js";
 /**
- * Makes one delivery and keeps whatever went wrong.
+ * Makes one delivery, with its retries, and keeps whatever went wrong.
  *
  * A failure is recorded rather than thrown, because these run as background
  * tasks and one left rejected would fail an unrelated
@@ -10,9 +11,11 @@ import { SimEventBridgeDeliveryFailures } from "./sim-event-bridge-delivery-fail
  */
 export class SimEventBridgeTargetDelivery {
     endpoints;
+    background;
     failures = new SimEventBridgeDeliveryFailures();
     constructor(properties) {
         this.endpoints = properties.endpoints;
+        this.background = properties.background;
     }
     /**
      * Every delivery that could not be made.
@@ -24,18 +27,20 @@ export class SimEventBridgeTargetDelivery {
      * Send one event to one target.
      */
     async deliver(request) {
-        try {
-            await this.endpoints.deliver(request);
-        }
-        catch (error) {
-            this.failures.record({
-                ruleName: request.ruleName,
-                ruleArn: request.ruleArn,
-                targetId: request.target.id,
-                targetArn: request.target.arn.value,
-                eventId: request.event.id,
-                error,
-            });
-        }
+        await new SimEventBridgeDeliveryAttempt({
+            request,
+            endpoints: this.endpoints,
+            background: this.background,
+            record: (error) => {
+                this.failures.record({
+                    ruleName: request.ruleName,
+                    ruleArn: request.ruleArn,
+                    targetId: request.target.id,
+                    targetArn: request.target.arn.value,
+                    eventId: request.event.id,
+                    error,
+                });
+            },
+        }).start();
     }
 }

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

@@ -12,4 +12,6 @@ export { SimEventRuleName } from "./rule/sim-event-rule-name.js";
 export { SimEventRuleState } from "./rule/sim-event-rule-state.js";
 export { SimEventPattern } from "./pattern/sim-event-pattern.js";
 export type { SimEventBusReceipt } from "./bus/sim-event-bus.js";
+export { partnerEventSourceArn, SimPartnerEventSource, type SimPartnerEventSourceState, } from "./source/sim-partner-event-source.js";
+export { isPartnerEventSourceName, SimPartnerEventSourceName, } from "./source/sim-partner-event-source-name.js";
 export { SimEventBridgeAccessDeniedException, SimEventBridgeError, SimEventBridgeInvalidEventPatternException, SimEventBridgeResourceAlreadyExistsException, SimEventBridgeResourceNotFoundException, SimEventBridgeUnsimulatedInputException, SimEventBridgeValidationException, } from "./error/sim-event-bridge.error.js";

package/dist/service/eventbridge/index.js

@@ -10,4 +10,6 @@ export { eventRuleArn } from "./rule/sim-event-rule-arn.js";
 export { SimEventRuleName } from "./rule/sim-event-rule-name.js";
 export { SimEventRuleState } from "./rule/sim-event-rule-state.js";
 export { SimEventPattern } from "./pattern/sim-event-pattern.js";
+export { partnerEventSourceArn, SimPartnerEventSource, } from "./source/sim-partner-event-source.js";
+export { isPartnerEventSourceName, SimPartnerEventSourceName, } from "./source/sim-partner-event-source-name.js";
 export { SimEventBridgeAccessDeniedException, SimEventBridgeError, SimEventBridgeInvalidEventPatternException, SimEventBridgeResourceAlreadyExistsException, SimEventBridgeResourceNotFoundException, SimEventBridgeUnsimulatedInputException, SimEventBridgeValidationException, } from "./error/sim-event-bridge.error.js";

package/dist/service/eventbridge/routing/sim-event-bridge-router.js

@@ -26,6 +26,7 @@ export class SimEventBridgeRouter {
         this.accountId = properties.accountId;
         this.delivery = new SimEventBridgeTargetDelivery({
             endpoints: properties.endpoints,
+            background: properties.background,
         });
     }
     /**

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

@@ -22,6 +22,10 @@ export class SimEventBridgeSdkCommandRouter {
                 "ListEventBusesCommand",
                 async (command, context) => await simEventBridge.listEventBuses(command, simSdkCallerOptions(context)),
             ],
+            [
+                "DescribeEventSourceCommand",
+                async (command, context) => await simEventBridge.describeEventSource(command, simSdkCallerOptions(context)),
+            ],
             [
                 "PutEventsCommand",
                 async (command, context) => await simEventBridge.putEvents(command, simSdkCallerOptions(context)),

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

@@ -1,4 +1,6 @@
 import type { SimEventBusStore } from "./bus/sim-event-bus-store.js";
+import type { SimEventBridgeCommands } from "./command/sim-event-bridge-commands.js";
+import type { SimEventBridgeDeliveryFailure } from "./delivery/sim-event-bridge-delivery-failures.js";
 import type { SimEventBusReceipt } from "./bus/sim-event-bus.js";
 import type { SimEventBus } from "./bus/sim-event-bus.js";
 import type { SimEventBridgeEvent } from "./event/sim-event-bridge-event.js";
@@ -20,6 +22,14 @@ export declare abstract class SimEventBridgeInspection {
     protected abstract readonly buses: SimEventBusStore;
     protected abstract readonly rules: SimEventRuleStore;
     protected abstract readonly targets: SimEventTargetStore;
+    protected abstract readonly commands: SimEventBridgeCommands;
+    /**
+     * Every event this scope's rules could not get to a target.
+     *
+     * Real EventBridge tells the caller nothing about a failed delivery, and
+     * neither does this. A target that is unexpectedly empty is explained here.
+     */
+    get deliveryFailures(): readonly SimEventBridgeDeliveryFailure[];
     /**
      * Find an event bus by name.
      *

package/dist/service/eventbridge/sim-event-bridge-inspection.js

@@ -10,6 +10,15 @@ import { defaultEventBusName } from "./bus/sim-event-bus-name.js";
  * job that happens to live on the same object.
  */
 export class SimEventBridgeInspection {
+    /**
+     * Every event this scope's rules could not get to a target.
+     *
+     * Real EventBridge tells the caller nothing about a failed delivery, and
+     * neither does this. A target that is unexpectedly empty is explained here.
+     */
+    get deliveryFailures() {
+        return this.commands.router.deliveryFailures;
+    }
     /**
      * Find an event bus by name.
      *

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

@@ -0,0 +1,38 @@
+import type { BackgroundScheduler } from "../../util/background/background.js";
+import type { SimAwsAccountRegionScope } from "../aws/sim-aws-account-region-scope.js";
+import type { SimPutPartnerEventsCommand, SimPutPartnerEventsCommandOutput } from "./command/source/source.command.js";
+import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
+import { SimPartnerEventSource } from "./source/sim-partner-event-source.js";
+import type { SimPartnerEventSourceStore } from "./source/sim-partner-event-source-store.js";
+/**
+ * What a test does as a SaaS partner sending events to a simulated Account.
+ *
+ * A partner such as Stripe works from its own Account, which is outside the
+ * simulation. It creates a partner event source shared with the receiving
+ * Account, and puts events onto it. Both are simulator accessors here rather
+ * than SDK commands, because the receiving Account's own clients never send
+ * either request.
+ */
+export declare abstract class SimEventBridgePartners extends SimEventBridgeInspection {
+    protected abstract readonly partnerSources: SimPartnerEventSourceStore;
+    protected abstract readonly background: BackgroundScheduler;
+    protected abstract readonly accountRegionScope: SimAwsAccountRegionScope;
+    /**
+     * Share a partner event source with this Account and Region, as the
+     * partner's CreatePartnerEventSource does.
+     *
+     * The source starts pending. Creating a bus with the same `Name` and
+     * `EventSourceName` activates it, and that bus then receives what
+     * `putPartnerEvents` sends.
+     */
+    addPartnerEventSource(name: string): SimPartnerEventSource;
+    /**
+     * Put events onto partner event buses as their partner would, taking the
+     * shape of the partner's PutPartnerEvents request.
+     *
+     * Each entry's `Source` has to name a source `addPartnerEventSource` shared
+     * with this scope. The event goes to the bus of the same name, or nowhere if
+     * that bus has not been created yet.
+     */
+    putPartnerEvents(command: SimPutPartnerEventsCommand): Promise<SimPutPartnerEventsCommandOutput>;
+}

package/dist/service/eventbridge/sim-event-bridge-partners.js

@@ -0,0 +1,43 @@
+import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
+import { SimPartnerEventSource } from "./source/sim-partner-event-source.js";
+import { SimPartnerEventSourceName } from "./source/sim-partner-event-source-name.js";
+/**
+ * What a test does as a SaaS partner sending events to a simulated Account.
+ *
+ * A partner such as Stripe works from its own Account, which is outside the
+ * simulation. It creates a partner event source shared with the receiving
+ * Account, and puts events onto it. Both are simulator accessors here rather
+ * than SDK commands, because the receiving Account's own clients never send
+ * either request.
+ */
+export class SimEventBridgePartners extends SimEventBridgeInspection {
+    /**
+     * Share a partner event source with this Account and Region, as the
+     * partner's CreatePartnerEventSource does.
+     *
+     * The source starts pending. Creating a bus with the same `Name` and
+     * `EventSourceName` activates it, and that bus then receives what
+     * `putPartnerEvents` sends.
+     */
+    addPartnerEventSource(name) {
+        const source = new SimPartnerEventSource({
+            name: SimPartnerEventSourceName.of(name, "Name"),
+            accountRegionScope: this.accountRegionScope,
+            createdAt: this.background.now(),
+        });
+        this.partnerSources.add(source);
+        return source;
+    }
+    /**
+     * Put events onto partner event buses as their partner would, taking the
+     * shape of the partner's PutPartnerEvents request.
+     *
+     * Each entry's `Source` has to name a source `addPartnerEventSource` shared
+     * with this scope. The event goes to the bus of the same name, or nowhere if
+     * that bus has not been created yet.
+     */
+    async putPartnerEvents(command) {
+        await this.background.sequence();
+        return this.commands.putPartnerEvents.handle(command);
+    }
+}

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

@@ -4,13 +4,14 @@ import type { SimAwsAccountRegionScope } from "../aws/sim-aws-account-region-sco
 import type { SimIamInterServiceAuthZ } from "../iam/authorize/sim-iam-inter-service-auth-z.js";
 import { SimEventBusStore } from "./bus/sim-event-bus-store.js";
 import type * as simEventBridgeCommands from "./command/sim-event-bridge-command.types.js";
+import { SimEventBridgeCommands } from "./command/sim-event-bridge-commands.js";
 import type { SimEventBridgeRequestOptions } from "./command/sim-event-bridge-request-options.js";
 import { SimEventRuleStore } from "./rule/sim-event-rule-store.js";
 import { SimEventTargetStore } from "./target/sim-event-target-store.js";
 import type { SimEventBridgeDeliveryTargets } from "./delivery/sim-event-bridge-delivery.js";
-import type { SimEventBridgeDeliveryFailure } from "./delivery/sim-event-bridge-delivery-failures.js";
 import { SimEventBridgeCfnResourceFactory } from "./cfn/sim-event-bridge-cfn-resource-factory.js";
-import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
+import { SimEventBridgePartners } from "./sim-event-bridge-partners.js";
+import { SimPartnerEventSourceStore } from "./source/sim-partner-event-source-store.js";
 interface SimEventBridgeProperties {
     readonly accountRegionScope?: SimAwsAccountRegionScope;
     readonly iam?: SimIamInterServiceAuthZ;
@@ -36,22 +37,17 @@ interface SimEventBridgeProperties {
  * matches nothing is gone. A rule carrying a schedule instead fires on the
  * simulation's own clock, so advancing time is what sends its event.
  */
-export declare class SimEventBridge extends SimEventBridgeInspection {
+export declare class SimEventBridge extends SimEventBridgePartners {
     protected readonly buses: SimEventBusStore;
     protected readonly rules: SimEventRuleStore;
     protected readonly targets: SimEventTargetStore;
-    private readonly commands;
-    private readonly background;
+    protected readonly partnerSources: SimPartnerEventSourceStore;
+    protected readonly commands: SimEventBridgeCommands;
+    protected readonly background: BackgroundScheduler;
+    protected readonly accountRegionScope: SimAwsAccountRegionScope;
     private readonly sdkRouter;
     private readonly cfnFactory;
     constructor(properties?: SimEventBridgeProperties);
-    /**
-     * Every event this scope's rules could not get to a target.
-     *
-     * Real EventBridge tells the caller nothing about a failed delivery, and
-     * neither does this. A target that is unexpectedly empty is explained here.
-     */
-    get deliveryFailures(): readonly SimEventBridgeDeliveryFailure[];
     /**
      * Handle a CreateEventBus Command from the SDK.
      */
@@ -68,6 +64,10 @@ export declare class SimEventBridge extends SimEventBridgeInspection {
      * Handle a ListEventBuses Command from the SDK.
      */
     listEventBuses(command: simEventBridgeCommands.SimListEventBusesCommand, options?: SimEventBridgeRequestOptions): Promise<simEventBridgeCommands.SimListEventBusesCommandOutput>;
+    /**
+     * Handle a DescribeEventSource Command from the SDK.
+     */
+    describeEventSource(command: simEventBridgeCommands.SimDescribeEventSourceCommand, options?: SimEventBridgeRequestOptions): Promise<simEventBridgeCommands.SimDescribeEventSourceCommandOutput>;
     /**
      * Handle a PutEvents Command from the SDK.
      */

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

@@ -8,7 +8,8 @@ import { SimEventRuleStore } from "./rule/sim-event-rule-store.js";
 import { SimEventTargetStore } from "./target/sim-event-target-store.js";
 import { SimEventBridgeCfnResourceFactory } from "./cfn/sim-event-bridge-cfn-resource-factory.js";
 import { SimEventBridgeSdkCommandRouter } from "./sdk/sim-event-bridge-sdk-command-router.js";
-import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
+import { SimEventBridgePartners } from "./sim-event-bridge-partners.js";
+import { SimPartnerEventSourceStore } from "./source/sim-partner-event-source-store.js";
 /**
  * Simulated EventBridge. Handles SDK commands. Emulates AWS behaviour and
  * state.
@@ -22,12 +23,14 @@ import { SimEventBridgeInspection } from "./sim-event-bridge-inspection.js";
  * matches nothing is gone. A rule carrying a schedule instead fires on the
  * simulation's own clock, so advancing time is what sends its event.
  */
-export class SimEventBridge extends SimEventBridgeInspection {
+export class SimEventBridge extends SimEventBridgePartners {
     buses;
     rules = new SimEventRuleStore();
     targets = new SimEventTargetStore();
+    partnerSources = new SimPartnerEventSourceStore();
     commands;
     background;
+    accountRegionScope;
     sdkRouter = new SimEventBridgeSdkCommandRouter(this);
     cfnFactory = new SimEventBridgeCfnResourceFactory({
         eventBridge: this,
@@ -37,26 +40,19 @@ export class SimEventBridge extends SimEventBridgeInspection {
         const { accountRegionScope = simAwsAccountRegionScopeFactory.make(), background = new BackgroundTasks(), } = properties;
         const iam = simIamInRegion(properties.iam, accountRegionScope.regionName);
         this.background = background;
+        this.accountRegionScope = accountRegionScope;
         this.buses = new SimEventBusStore(SimEventBus.default({ accountRegionScope, createdAt: background.now() }));
         this.commands = new SimEventBridgeCommands({
             buses: this.buses,
             rules: this.rules,
             targets: this.targets,
+            partnerSources: this.partnerSources,
             deliveryTargets: properties.deliveryTargets,
             iam,
             background,
             accountRegionScope,
         });
     }
-    /**
-     * Every event this scope's rules could not get to a target.
-     *
-     * Real EventBridge tells the caller nothing about a failed delivery, and
-     * neither does this. A target that is unexpectedly empty is explained here.
-     */
-    get deliveryFailures() {
-        return this.commands.router.deliveryFailures;
-    }
     /**
      * Handle a CreateEventBus Command from the SDK.
      */
@@ -85,6 +81,13 @@ export class SimEventBridge extends SimEventBridgeInspection {
         await this.background.sequence();
         return this.commands.buses.listEventBuses(command, options);
     }
+    /**
+     * Handle a DescribeEventSource Command from the SDK.
+     */
+    async describeEventSource(command, options) {
+        await this.background.sequence();
+        return this.commands.eventSources.handle(command, options);
+    }
     /**
      * Handle a PutEvents Command from the SDK.
      */

package/dist/service/eventbridge/source/sim-partner-event-source-name.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Whether a string has the shape of a partner event source name.
+ *
+ * A partner event bus takes the name of its source, so this is also the one
+ * shape of bus name that may carry a `/`.
+ */
+export declare function isPartnerEventSourceName(value: string): boolean;
+/**
+ * The name of one partner event source.
+ *
+ * A SaaS partner names the source when it creates it, in the form
+ * `aws.partner/<partner>/<name>`. The receiving Account never chooses the
+ * name. It creates a bus under the same one.
+ */
+export declare class SimPartnerEventSourceName {
+    readonly value: string;
+    private constructor();
+    /**
+     * Read a partner event source name from request input, refusing one real
+     * EventBridge would refuse.
+     */
+    static of(value: string, parameterName: string): SimPartnerEventSourceName;
+    /**
+     * The partner that created the source, which is the segment after
+     * `aws.partner`.
+     */
+    get partner(): string;
+}

package/dist/service/eventbridge/source/sim-partner-event-source-name.js

@@ -0,0 +1,62 @@
+import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
+const partnerPrefix = "aws.partner/";
+/**
+ * The characters one segment of a partner event source name may carry.
+ */
+const partnerSegmentPattern = /^[.\-_A-Za-z0-9]+$/;
+/**
+ * Real EventBridge wants the partner's own name and at least one more segment
+ * after the prefix, such as `aws.partner/stripe.com/ed_test`.
+ */
+const minimumPartnerSegments = 2;
+const maximumPartnerEventSourceNameLength = 256;
+const partnerSegmentStart = partnerPrefix.length;
+/**
+ * Whether a string has the shape of a partner event source name.
+ *
+ * A partner event bus takes the name of its source, so this is also the one
+ * shape of bus name that may carry a `/`.
+ */
+export function isPartnerEventSourceName(value) {
+    // Read segment by segment, which is the API's own pattern
+    // `aws\.partner(/[\.\-_A-Za-z0-9]+){2,}` without the nested repetition.
+    const segments = value.slice(partnerSegmentStart).split("/");
+    return (value.length <= maximumPartnerEventSourceNameLength &&
+        value.startsWith(partnerPrefix) &&
+        segments.length >= minimumPartnerSegments &&
+        segments.every((segment) => partnerSegmentPattern.test(segment)));
+}
+/**
+ * The name of one partner event source.
+ *
+ * A SaaS partner names the source when it creates it, in the form
+ * `aws.partner/<partner>/<name>`. The receiving Account never chooses the
+ * name. It creates a bus under the same one.
+ */
+export class SimPartnerEventSourceName {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+    /**
+     * Read a partner event source name from request input, refusing one real
+     * EventBridge would refuse.
+     */
+    static of(value, parameterName) {
+        if (!isPartnerEventSourceName(value)) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: ${parameterName} Reason: '${value}' is not a ` +
+                `partner event source name, which takes the form ` +
+                `aws.partner/<partner>/<name> and is at most ` +
+                `${String(maximumPartnerEventSourceNameLength)} characters long.`);
+        }
+        return new this(value);
+    }
+    /**
+     * The partner that created the source, which is the segment after
+     * `aws.partner`.
+     */
+    get partner() {
+        // The pattern guarantees a `/` after the partner segment.
+        return this.value.slice(partnerSegmentStart, this.value.indexOf("/", partnerSegmentStart));
+    }
+}

package/dist/service/eventbridge/source/sim-partner-event-source-store.d.ts

@@ -0,0 +1,18 @@
+import type { SimPartnerEventSource } from "./sim-partner-event-source.js";
+/**
+ * The partner event sources shared with one simulated EventBridge scope.
+ *
+ * Sources are keyed by name. A partner names each one uniquely across every
+ * Account it serves, so a name is enough to find one.
+ */
+export declare class SimPartnerEventSourceStore {
+    private readonly sources;
+    /**
+     * Store a newly created source, refusing a name already taken.
+     */
+    add(source: SimPartnerEventSource): void;
+    /**
+     * Resolve a source by name, or refuse.
+     */
+    require(name: string): SimPartnerEventSource;
+}

package/dist/service/eventbridge/source/sim-partner-event-source-store.js

@@ -0,0 +1,29 @@
+import { SimEventBridgeResourceAlreadyExistsException, SimEventBridgeResourceNotFoundException, } from "../error/sim-event-bridge.error.js";
+/**
+ * The partner event sources shared with one simulated EventBridge scope.
+ *
+ * Sources are keyed by name. A partner names each one uniquely across every
+ * Account it serves, so a name is enough to find one.
+ */
+export class SimPartnerEventSourceStore {
+    sources = new Map();
+    /**
+     * Store a newly created source, refusing a name already taken.
+     */
+    add(source) {
+        if (this.sources.has(source.name.value)) {
+            throw new SimEventBridgeResourceAlreadyExistsException(`Event source ${source.name.value} already exists.`);
+        }
+        this.sources.set(source.name.value, source);
+    }
+    /**
+     * Resolve a source by name, or refuse.
+     */
+    require(name) {
+        const found = this.sources.get(name);
+        if (found === undefined) {
+            throw new SimEventBridgeResourceNotFoundException(`Event source ${name} does not exist.`);
+        }
+        return found;
+    }
+}

package/dist/service/eventbridge/source/sim-partner-event-source.d.ts

@@ -0,0 +1,46 @@
+import type { SimAwsAccountRegionScope } from "../../aws/sim-aws-account-region-scope.js";
+import type { SimPartnerEventSourceName } from "./sim-partner-event-source-name.js";
+/**
+ * The states a partner event source reports.
+ *
+ * `DELETED` is absent. It belongs to a source the partner deleted while its
+ * bus was still there, and nothing here deletes a source.
+ */
+export type SimPartnerEventSourceState = "ACTIVE" | "PENDING";
+/**
+ * The ARN of a partner event source, which a request authorizes against
+ * before the source is looked up.
+ *
+ * The ARN carries no Account. The source is the partner's resource, shared
+ * with the receiving Account, and real EventBridge writes it with an empty
+ * Account field, as the `resources` of a Stripe event show.
+ */
+export declare function partnerEventSourceArn(name: SimPartnerEventSourceName, accountRegionScope: SimAwsAccountRegionScope): string;
+interface SimPartnerEventSourceProperties {
+    readonly name: SimPartnerEventSourceName;
+    readonly accountRegionScope: SimAwsAccountRegionScope;
+    readonly createdAt: Date;
+}
+/**
+ * One partner event source, shared with a receiving Account and Region.
+ *
+ * A SaaS partner creates the source from its own Account, naming the Account
+ * that may receive from it. The receiving Account activates it by creating a
+ * partner event bus under the same name, and the partner's events then land
+ * on that bus.
+ *
+ * The state is worked out from whether that bus exists rather than stored
+ * here. Creating the bus is what activates a source on real AWS, and deleting
+ * the bus puts it back to pending.
+ */
+export declare class SimPartnerEventSource {
+    readonly name: SimPartnerEventSourceName;
+    readonly arn: string;
+    readonly creationTime: Date;
+    constructor(properties: SimPartnerEventSourceProperties);
+    /**
+     * The source's state, given whether a bus of its name exists.
+     */
+    state(hasBus: boolean): SimPartnerEventSourceState;
+}
+export {};

package/dist/service/eventbridge/source/sim-partner-event-source.js

@@ -0,0 +1,43 @@
+/**
+ * The ARN of a partner event source, which a request authorizes against
+ * before the source is looked up.
+ *
+ * The ARN carries no Account. The source is the partner's resource, shared
+ * with the receiving Account, and real EventBridge writes it with an empty
+ * Account field, as the `resources` of a Stripe event show.
+ */
+export function partnerEventSourceArn(name, accountRegionScope) {
+    return `arn:aws:events:${accountRegionScope.regionName}::event-source/${name.value}`;
+}
+/**
+ * One partner event source, shared with a receiving Account and Region.
+ *
+ * A SaaS partner creates the source from its own Account, naming the Account
+ * that may receive from it. The receiving Account activates it by creating a
+ * partner event bus under the same name, and the partner's events then land
+ * on that bus.
+ *
+ * The state is worked out from whether that bus exists rather than stored
+ * here. Creating the bus is what activates a source on real AWS, and deleting
+ * the bus puts it back to pending.
+ */
+export class SimPartnerEventSource {
+    name;
+    arn;
+    creationTime;
+    constructor(properties) {
+        const { name, accountRegionScope } = properties;
+        this.name = name;
+        this.arn = partnerEventSourceArn(name, accountRegionScope);
+        this.creationTime = properties.createdAt;
+    }
+    /**
+     * The source's state, given whether a bus of its name exists.
+     */
+    state(hasBus) {
+        if (hasBus) {
+            return "ACTIVE";
+        }
+        return "PENDING";
+    }
+}

package/dist/service/eventbridge/target/sim-event-target-dead-letter-config.d.ts

@@ -0,0 +1,28 @@
+import { type SimSqsQueueLocation } from "../../sqs/queue/sim-sqs-queue-arn.js";
+/**
+ * A target's `DeadLetterConfig`, as a request or a template carries it.
+ */
+export interface SimEventTargetDeadLetterConfigInput {
+    readonly Arn?: string | undefined;
+}
+/**
+ * The standard SQS queue a target sends an event to once EventBridge gives up
+ * delivering it.
+ */
+export declare class SimEventTargetDeadLetterConfig {
+    readonly declared: SimEventTargetDeadLetterConfigInput;
+    readonly arn: string;
+    readonly queue: SimSqsQueueLocation;
+    private constructor();
+    /**
+     * Read the dead-letter configuration a target may leave out.
+     */
+    static optional(config: SimEventTargetDeadLetterConfigInput | undefined): SimEventTargetDeadLetterConfig | undefined;
+    /**
+     * Read a dead-letter configuration, refusing anything but a standard queue.
+     *
+     * Real EventBridge takes only a standard queue here. A FIFO queue is refused
+     * by its name, which always ends `.fifo`.
+     */
+    static of(config: SimEventTargetDeadLetterConfigInput): SimEventTargetDeadLetterConfig;
+}

package/dist/service/eventbridge/target/sim-event-target-dead-letter-config.js

@@ -0,0 +1,42 @@
+import { parseSqsQueueArn, } from "../../sqs/queue/sim-sqs-queue-arn.js";
+import { SimEventBridgeValidationException } from "../error/sim-event-bridge.error.js";
+const fifoQueueSuffix = ".fifo";
+/**
+ * The standard SQS queue a target sends an event to once EventBridge gives up
+ * delivering it.
+ */
+export class SimEventTargetDeadLetterConfig {
+    declared;
+    arn;
+    queue;
+    constructor(declared, arn, queue) {
+        this.declared = { ...declared };
+        this.arn = arn;
+        this.queue = queue;
+    }
+    /**
+     * Read the dead-letter configuration a target may leave out.
+     */
+    static optional(config) {
+        if (config === undefined) {
+            return undefined;
+        }
+        return this.of(config);
+    }
+    /**
+     * Read a dead-letter configuration, refusing anything but a standard queue.
+     *
+     * Real EventBridge takes only a standard queue here. A FIFO queue is refused
+     * by its name, which always ends `.fifo`.
+     */
+    static of(config) {
+        const arn = config.Arn ?? "";
+        const queue = parseSqsQueueArn(arn);
+        if (queue === undefined || queue.name.endsWith(fifoQueueSuffix)) {
+            throw new SimEventBridgeValidationException(`Invalid parameter: Target DeadLetterConfig Arn Reason: '${arn}' is ` +
+                `not a standard SQS queue ARN. One is ` +
+                `arn:aws:sqs:<region>:<account-id>:<queue-name>.`);
+        }
+        return new this(config, arn, queue);
+    }
+}