agent-claw: automated task changes

cdk/node_modules/aws-cdk-lib/aws-events/lib/rule.d.ts

@@ -0,0 +1,167 @@
+import type { Construct } from 'constructs';
+import type { EventPattern } from './event-pattern';
+import type { IEventBusRef, RuleReference } from './events.generated';
+import type { EventCommonOptions } from './on-event-options';
+import type { IRule } from './rule-ref';
+import { Schedule } from './schedule';
+import type { IRuleTarget } from './target';
+import type { IRoleRef } from '../../aws-iam';
+import { Resource } from '../../core';
+/**
+ * Properties for defining an EventBridge Rule
+ */
+export interface RuleProps extends EventCommonOptions {
+    /**
+     * Indicates whether the rule is enabled.
+     *
+     * @default true
+     */
+    readonly enabled?: boolean;
+    /**
+     * The schedule or rate (frequency) that determines when EventBridge
+     * runs the rule.
+     *
+     * You must specify this property, the `eventPattern` property, or both.
+     *
+     * For more information, see Schedule Expression Syntax for
+     * Rules in the Amazon EventBridge User Guide.
+     *
+     * @see https://docs.aws.amazon.com/eventbridge/latest/userguide/scheduled-events.html
+     *
+     * @default - None.
+     */
+    readonly schedule?: Schedule;
+    /**
+     * Targets to invoke when this rule matches an event.
+     *
+     * Input will be the full matched event. If you wish to specify custom
+     * target input, use `addTarget(target[, inputOptions])`.
+     *
+     * @default - No targets.
+     */
+    readonly targets?: IRuleTarget[];
+    /**
+     * The event bus to associate with this rule.
+     *
+     * @default - The default event bus.
+     */
+    readonly eventBus?: IEventBusRef;
+    /**
+     * The role that is used for target invocation.
+     * Must be assumable by principal `events.amazonaws.com`.
+     *
+     * @default - No role associated
+     */
+    readonly role?: IRoleRef;
+}
+/**
+ * Defines an EventBridge Rule in this stack.
+ *
+ * @resource AWS::Events::Rule
+ */
+export declare class Rule extends Resource implements IRule {
+    /** Uniquely identifies this class. */
+    static readonly PROPERTY_INJECTION_ID: string;
+    /**
+     * Import an existing EventBridge Rule provided an ARN
+     *
+     * @param scope The parent creating construct (usually `this`).
+     * @param id The construct's name.
+     * @param eventRuleArn Event Rule ARN (i.e. arn:aws:events:<region>:<account-id>:rule/MyScheduledRule).
+     */
+    static fromEventRuleArn(scope: Construct, id: string, eventRuleArn: string): IRule;
+    /**
+     * The CfnRule resource
+     */
+    private readonly _resource;
+    get ruleArn(): string;
+    get ruleName(): string;
+    get ruleRef(): RuleReference;
+    private readonly targets;
+    private readonly eventPattern;
+    private readonly scheduleExpression?;
+    private readonly description?;
+    /** Set to keep track of what target accounts and regions we've already created event buses for */
+    private readonly _xEnvTargetsAdded;
+    constructor(scope: Construct, id: string, props?: RuleProps);
+    /**
+     * Adds a target to the rule. The abstract class RuleTarget can be extended to define new
+     * targets.
+     *
+     * No-op if target is undefined.
+     */
+    addTarget(target?: IRuleTarget): void;
+    /**
+     * Adds an event pattern filter to this rule. If a pattern was already specified,
+     * these values are merged into the existing pattern.
+     *
+     * For example, if the rule already contains the pattern:
+     *
+     *    {
+     *      "resources": [ "r1" ],
+     *      "detail": {
+     *        "hello": [ 1 ]
+     *      }
+     *    }
+     *
+     * And `addEventPattern` is called with the pattern:
+     *
+     *    {
+     *      "resources": [ "r2" ],
+     *      "detail": {
+     *        "foo": [ "bar" ]
+     *      }
+     *    }
+     *
+     * The resulting event pattern will be:
+     *
+     *    {
+     *      "resources": [ "r1", "r2" ],
+     *      "detail": {
+     *        "hello": [ 1 ],
+     *        "foo": [ "bar" ]
+     *      }
+     *    }
+     *
+     */
+    addEventPattern(eventPattern?: EventPattern): void;
+    /**
+     * Not private only to be overrideen in CopyRule.
+     *
+     * @internal
+     */
+    _renderEventPattern(): any;
+    protected validateRule(): string[];
+    private renderTargets;
+    /**
+     * Make sure we add the target environments event bus as a target, and the target has permissions set up to receive our events
+     *
+     * For cross-account rules, uses a support stack to set up a policy on the target event bus.
+     */
+    private ensureXEnvTargetEventBus;
+    /**
+     * Return the scope where the mirror rule should be created for x-env event targets
+     *
+     * This is the target resource's containing stack if it shares the same region (owned
+     * resources), or should be a fresh support stack for imported resources.
+     *
+     * We don't implement the second yet, as I have to think long and hard on whether we
+     * can reuse the existing support stack or not, and I don't have time for that right now.
+     */
+    private obtainMirrorRuleScope;
+    /**
+     * Obtain the Role for the EventBridge event
+     *
+     * If a role already exists, it will be returned. This ensures that if multiple
+     * events have the same target, they will share a role.
+     * @internal
+     */
+    private crossRegionPutEventsRole;
+    /**
+     * Whether two string probably contain the same environment dimension (region or account)
+     *
+     * Used to compare either accounts or regions, and also returns true if one or both
+     * are unresolved (in which case both are expected to be "current region" or "current account").
+     */
+    private sameEnvDimension;
+}