@jaypie/constructs 1.1.65 → 1.1.66

package/dist/cjs/index.d.ts

@@ -0,0 +1,29 @@
+export { CDK } from "./constants";
+export { JaypieAccountLoggingBucket, JaypieAccountLoggingBucketProps, } from "./JaypieAccountLoggingBucket";
+export { JaypieApiGateway } from "./JaypieApiGateway";
+export { JaypieAppStack } from "./JaypieAppStack";
+export { JaypieBucketQueuedLambda } from "./JaypieBucketQueuedLambda";
+export { JaypieDatadogBucket, JaypieDatadogBucketProps, } from "./JaypieDatadogBucket";
+export { JaypieDatadogForwarder, JaypieDatadogForwarderProps, } from "./JaypieDatadogForwarder";
+export { JaypieDistribution, JaypieDistributionProps, } from "./JaypieDistribution";
+export { JaypieDatadogSecret } from "./JaypieDatadogSecret";
+export { JaypieDnsRecord, JaypieDnsRecordProps } from "./JaypieDnsRecord";
+export { JaypieEnvSecret } from "./JaypieEnvSecret";
+export { JaypieEventsRule, JaypieEventsRuleProps } from "./JaypieEventsRule";
+export { JaypieGitHubDeployRole, JaypieGitHubDeployRoleProps, } from "./JaypieGitHubDeployRole";
+export { JaypieExpressLambda } from "./JaypieExpressLambda";
+export { JaypieHostedZone, JaypieHostedZoneRecordProps, } from "./JaypieHostedZone";
+export { JaypieInfrastructureStack } from "./JaypieInfrastructureStack";
+export { JaypieLambda, JaypieLambdaProps } from "./JaypieLambda";
+export { JaypieMongoDbSecret } from "./JaypieMongoDbSecret";
+export { JaypieNextJs, JaypieNextjsProps } from "./JaypieNextJs";
+export { JaypieOpenAiSecret } from "./JaypieOpenAiSecret";
+export { JaypieOrganizationTrail, JaypieOrganizationTrailProps, } from "./JaypieOrganizationTrail";
+export { AccountAssignments, JaypieSsoPermissions, JaypieSsoPermissionsProps, } from "./JaypieSsoPermissions";
+export { JaypieSsoSyncApplication, JaypieSsoSyncApplicationProps, } from "./JaypieSsoSyncApplication";
+export { JaypieQueuedLambda } from "./JaypieQueuedLambda";
+export { JaypieStack, JaypieStackProps } from "./JaypieStack";
+export { JaypieStaticWebBucket, JaypieStaticWebBucketProps, } from "./JaypieStaticWebBucket";
+export { JaypieTraceSigningKeySecret } from "./JaypieTraceSigningKeySecret";
+export { JaypieWebDeploymentBucket } from "./JaypieWebDeploymentBucket";
+export * from "./helpers";

package/dist/esm/JaypieAccountLoggingBucket.d.ts

@@ -0,0 +1,60 @@
+import { BucketProps, IBucket } from "aws-cdk-lib/aws-s3";
+import { Construct } from "constructs";
+export interface JaypieAccountLoggingBucketProps extends BucketProps {
+    /**
+     * Optional construct ID
+     * @default "AccountLoggingBucket"
+     */
+    id?: string;
+    /**
+     * Bucket name
+     * @default `account-logging-stack-${PROJECT_NONCE}`
+     */
+    bucketName?: string;
+    /**
+     * The service tag value
+     * @default CDK.SERVICE.INFRASTRUCTURE
+     */
+    service?: string;
+    /**
+     * Optional project tag value
+     */
+    project?: string;
+    /**
+     * Number of days before logs expire
+     * @default 365
+     */
+    expirationDays?: number;
+    /**
+     * Number of days before transitioning to INFREQUENT_ACCESS storage
+     * @default 30
+     */
+    infrequentAccessTransitionDays?: number;
+    /**
+     * Number of days before transitioning to GLACIER storage
+     * @default 180
+     */
+    glacierTransitionDays?: number;
+    /**
+     * Whether to create CloudFormation output for bucket name
+     * @default true
+     */
+    createOutput?: boolean;
+    /**
+     * Custom export name for the bucket name output
+     * @default CDK.IMPORT.LOG_BUCKET
+     */
+    exportName?: string;
+    /**
+     * Description for the CloudFormation output
+     * @default "Account-wide logging bucket"
+     */
+    outputDescription?: string;
+}
+export declare class JaypieAccountLoggingBucket extends Construct {
+    readonly bucket: IBucket;
+    /**
+     * Create a new account-wide logging S3 bucket with lifecycle policies and export
+     */
+    constructor(scope: Construct, idOrProps?: string | JaypieAccountLoggingBucketProps, propsOrUndefined?: JaypieAccountLoggingBucketProps);
+}

package/dist/esm/JaypieApiGateway.d.ts

@@ -0,0 +1,47 @@
+import { Construct } from "constructs";
+import { RemovalPolicy, Stack } from "aws-cdk-lib";
+import * as acm from "aws-cdk-lib/aws-certificatemanager";
+import * as apiGateway from "aws-cdk-lib/aws-apigateway";
+import * as route53 from "aws-cdk-lib/aws-route53";
+export interface JaypieApiGatewayProps extends apiGateway.LambdaRestApiProps {
+    certificate?: boolean | acm.ICertificate;
+    host?: string;
+    name?: string;
+    roleTag?: string;
+    zone?: string | route53.IHostedZone;
+}
+export declare class JaypieApiGateway extends Construct implements apiGateway.IRestApi {
+    private readonly _api;
+    private readonly _certificate?;
+    private readonly _domainName?;
+    private readonly _host?;
+    constructor(scope: Construct, id: string, props: JaypieApiGatewayProps);
+    get api(): apiGateway.LambdaRestApi;
+    get url(): string;
+    get certificateArn(): string | undefined;
+    get domainName(): string | undefined;
+    get host(): string | undefined;
+    get restApiId(): string;
+    get restApiName(): string;
+    get restApiRootResourceId(): string;
+    get deploymentStage(): apiGateway.Stage;
+    get domainNameAliasDomainName(): string | undefined;
+    get domainNameAliasHostedZoneId(): string | undefined;
+    get root(): apiGateway.IResource;
+    get env(): {
+        account: string;
+        region: string;
+    };
+    get stack(): Stack;
+    arnForExecuteApi(method?: string, path?: string, stage?: string): string;
+    metric(metricName: string, props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricCacheHitCount(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricCacheMissCount(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricClientError(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricCount(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricIntegrationLatency(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricLatency(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    metricServerError(props?: import("aws-cdk-lib/aws-cloudwatch").MetricOptions): import("aws-cdk-lib/aws-cloudwatch").Metric;
+    applyRemovalPolicy(policy: RemovalPolicy): void;
+    get restApiRef(): apiGateway.RestApiReference;
+}

package/dist/esm/JaypieAppStack.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { JaypieStack, JaypieStackProps } from "./JaypieStack";
+export declare class JaypieAppStack extends JaypieStack {
+    constructor(scope: Construct, id: string, props?: JaypieStackProps);
+}

package/dist/esm/JaypieBucketQueuedLambda.d.ts

@@ -0,0 +1,48 @@
+import { Construct } from "constructs";
+import { RemovalPolicy } from "aws-cdk-lib";
+import * as s3 from "aws-cdk-lib/aws-s3";
+import * as iam from "aws-cdk-lib/aws-iam";
+import { JaypieQueuedLambda, JaypieQueuedLambdaProps } from "./JaypieQueuedLambda.js";
+export interface JaypieBucketQueuedLambdaProps extends JaypieQueuedLambdaProps {
+    bucketName?: string;
+    bucketOptions?: s3.BucketProps;
+}
+export declare class JaypieBucketQueuedLambda extends JaypieQueuedLambda implements s3.IBucket {
+    private readonly _bucket;
+    constructor(scope: Construct, id: string, props: JaypieBucketQueuedLambdaProps);
+    get bucket(): s3.Bucket;
+    get bucketArn(): string;
+    get bucketDomainName(): string;
+    get bucketDualStackDomainName(): string;
+    get bucketName(): string;
+    get bucketRegionalDomainName(): string;
+    get bucketWebsiteDomainName(): string;
+    get bucketWebsiteUrl(): string;
+    get encryptionKey(): undefined | import("aws-cdk-lib/aws-kms").IKey;
+    get isWebsite(): boolean;
+    get policy(): s3.BucketPolicy | undefined;
+    addEventNotification(event: s3.EventType, dest: s3.IBucketNotificationDestination, ...filters: s3.NotificationKeyFilter[]): void;
+    addObjectCreatedNotification(dest: s3.IBucketNotificationDestination, ...filters: s3.NotificationKeyFilter[]): void;
+    addObjectRemovedNotification(dest: s3.IBucketNotificationDestination, ...filters: s3.NotificationKeyFilter[]): void;
+    addToResourcePolicy(permission: iam.PolicyStatement): iam.AddToResourcePolicyResult;
+    arnForObjects(objectKeyPattern: string): string;
+    enableEventBridgeNotification(): void;
+    grantDelete(grantee: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;
+    grantPublicAccess(keyPrefix?: string, ...allowedActions: string[]): iam.Grant;
+    grantPut(grantee: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;
+    grantPutAcl(grantee: iam.IGrantable, objectsKeyPattern?: string): iam.Grant;
+    grantRead(grantee: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;
+    grantReadWrite(grantee: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;
+    grantWrite(grantee: iam.IGrantable, objectsKeyPattern?: any): iam.Grant;
+    onCloudTrailEvent(id: string, options?: s3.OnCloudTrailBucketEventOptions): import("aws-cdk-lib/aws-events").Rule;
+    onCloudTrailPutObject(id: string, options?: s3.OnCloudTrailBucketEventOptions): import("aws-cdk-lib/aws-events").Rule;
+    onCloudTrailWriteObject(id: string, options?: s3.OnCloudTrailBucketEventOptions): import("aws-cdk-lib/aws-events").Rule;
+    s3UrlForObject(key?: string): string;
+    transferAccelerationUrlForObject(key?: string, options?: s3.TransferAccelerationUrlOptions): string;
+    urlForObject(key?: string): string;
+    virtualHostedUrlForObject(key?: string, options?: s3.VirtualHostedStyleUrlOptions): string;
+    grantReplicationPermission(identity: iam.IGrantable, props: any): iam.Grant;
+    addReplicationPolicy(policy: any): void;
+    get bucketRef(): s3.BucketReference;
+    applyRemovalPolicy(policy: RemovalPolicy): void;
+}

package/dist/esm/JaypieDatadogBucket.d.ts

@@ -0,0 +1,55 @@
+import { Policy } from "aws-cdk-lib/aws-iam";
+import { BucketProps, IBucket } from "aws-cdk-lib/aws-s3";
+import { Construct } from "constructs";
+export interface JaypieDatadogBucketProps extends BucketProps {
+    /**
+     * Optional construct ID
+     * @default "JaypieDatadogBucket"
+     */
+    id?: string;
+    /**
+     * The scope to use when creating the S3 bucket
+     * @default this (the construct itself)
+     */
+    bucketScope?: Construct;
+    /**
+     * The ID to use for the S3 bucket construct
+     * @default "DatadogArchiveBucket"
+     */
+    bucketId?: string;
+    /**
+     * The service tag value
+     * @default CDK.SERVICE.DATADOG
+     */
+    service?: string;
+    /**
+     * Optional project tag value
+     */
+    project?: string;
+    /**
+     * Whether to grant Datadog role access to this bucket
+     * Uses CDK_ENV_DATADOG_ROLE_ARN if set
+     * @default true
+     */
+    grantDatadogAccess?: boolean;
+}
+export declare class JaypieDatadogBucket extends Construct {
+    readonly bucket: IBucket;
+    readonly policy?: Policy;
+    /**
+     * Create a new S3 bucket for Datadog log archiving with automatic IAM permissions
+     */
+    constructor(scope: Construct, idOrProps?: string | JaypieDatadogBucketProps, propsOrUndefined?: JaypieDatadogBucketProps);
+    /**
+     * Grants the Datadog IAM role access to this bucket
+     *
+     * Checks for CDK_ENV_DATADOG_ROLE_ARN environment variable.
+     * If found, creates a custom policy with:
+     * - s3:ListBucket on bucket
+     * - s3:GetObject and s3:PutObject on bucket/*
+     *
+     * @param options - Configuration options
+     * @returns The created Policy, or undefined if CDK_ENV_DATADOG_ROLE_ARN is not set
+     */
+    private grantDatadogRoleBucketAccess;
+}

package/dist/esm/JaypieDatadogForwarder.d.ts

@@ -0,0 +1,76 @@
+import { CfnStack } from "aws-cdk-lib";
+import { Rule } from "aws-cdk-lib/aws-events";
+import { IFunction } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+export interface JaypieDatadogForwarderProps {
+    /**
+     * Optional construct ID
+     * @default "DatadogForwarder"
+     */
+    id?: string;
+    /**
+     * Datadog API key
+     * @default process.env.CDK_ENV_DATADOG_API_KEY
+     */
+    datadogApiKey?: string;
+    /**
+     * Account identifier for Datadog tags
+     * @default process.env.CDK_ENV_ACCOUNT
+     */
+    account?: string;
+    /**
+     * Reserved concurrency for the forwarder Lambda
+     * Must be a string as required by the CloudFormation template
+     * @default "10"
+     */
+    reservedConcurrency?: string;
+    /**
+     * Additional Datadog tags (comma-separated)
+     * Will be appended to account tag
+     */
+    additionalTags?: string;
+    /**
+     * The service tag value
+     * @default CDK.VENDOR.DATADOG
+     */
+    service?: string;
+    /**
+     * Optional project tag value
+     */
+    project?: string;
+    /**
+     * Whether to create CloudFormation events rule
+     * @default true
+     */
+    enableCloudFormationEvents?: boolean;
+    /**
+     * Whether to extend Datadog role with custom permissions
+     * Uses CDK_ENV_DATADOG_ROLE_ARN if set
+     * @default true
+     */
+    enableRoleExtension?: boolean;
+    /**
+     * Whether to create CloudFormation output for forwarder ARN
+     * @default true
+     */
+    createOutput?: boolean;
+    /**
+     * Custom export name for the forwarder ARN output
+     * @default CDK.IMPORT.DATADOG_LOG_FORWARDER
+     */
+    exportName?: string;
+    /**
+     * URL to Datadog forwarder CloudFormation template
+     * @default "https://datadog-cloudformation-template.s3.amazonaws.com/aws/forwarder/latest.yaml"
+     */
+    templateUrl?: string;
+}
+export declare class JaypieDatadogForwarder extends Construct {
+    readonly cfnStack: CfnStack;
+    readonly forwarderFunction: IFunction;
+    readonly eventsRule?: Rule;
+    /**
+     * Create a new Datadog forwarder with CloudFormation nested stack
+     */
+    constructor(scope: Construct, idOrProps?: string | JaypieDatadogForwarderProps, propsOrUndefined?: JaypieDatadogForwarderProps);
+}

package/dist/esm/JaypieDatadogSecret.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { JaypieEnvSecret, JaypieEnvSecretProps } from "./JaypieEnvSecret";
+export declare class JaypieDatadogSecret extends JaypieEnvSecret {
+    constructor(scope: Construct, id?: string, props?: JaypieEnvSecretProps);
+}

package/dist/esm/JaypieDistribution.d.ts

@@ -0,0 +1,76 @@
+import { RemovalPolicy, Stack } from "aws-cdk-lib";
+import * as acm from "aws-cdk-lib/aws-certificatemanager";
+import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as route53 from "aws-cdk-lib/aws-route53";
+import * as s3 from "aws-cdk-lib/aws-s3";
+import { LambdaDestination } from "aws-cdk-lib/aws-s3-notifications";
+import { Construct } from "constructs";
+export interface JaypieDistributionProps extends Omit<cloudfront.DistributionProps, "certificate" | "defaultBehavior"> {
+    /**
+     * SSL certificate for the CloudFront distribution
+     * @default true (creates a new certificate)
+     */
+    certificate?: boolean | acm.ICertificate;
+    /**
+     * Override default behavior (optional if handler is provided)
+     */
+    defaultBehavior?: cloudfront.BehaviorOptions;
+    /**
+     * Log destination configuration for CloudFront access logs
+     * - LambdaDestination: Use a specific Lambda destination for S3 notifications
+     * - true: Use Datadog forwarder for S3 notifications (default)
+     * - false: Disable logging entirely
+     * @default true
+     */
+    destination?: LambdaDestination | boolean;
+    /**
+     * The origin handler - can be an IOrigin, IFunctionUrl, or IFunction
+     * If IFunction, a FunctionUrl will be created with auth NONE
+     */
+    handler?: cloudfront.IOrigin | lambda.IFunctionUrl | lambda.IFunction;
+    /**
+     * The domain name for the distribution
+     * @default mergeDomain(CDK_ENV_API_SUBDOMAIN, CDK_ENV_API_HOSTED_ZONE || CDK_ENV_HOSTED_ZONE)
+     */
+    host?: string;
+    /**
+     * Invoke mode for Lambda Function URLs
+     * @default InvokeMode.BUFFERED
+     */
+    invokeMode?: lambda.InvokeMode;
+    /**
+     * Role tag for tagging resources
+     * @default CDK.ROLE.HOSTING
+     */
+    roleTag?: string;
+    /**
+     * The hosted zone for DNS records
+     * @default CDK_ENV_API_HOSTED_ZONE || CDK_ENV_HOSTED_ZONE
+     */
+    zone?: string | route53.IHostedZone;
+}
+export declare class JaypieDistribution extends Construct implements cloudfront.IDistribution {
+    readonly certificate?: acm.ICertificate;
+    readonly distribution: cloudfront.Distribution;
+    readonly distributionArn: string;
+    readonly distributionDomainName: string;
+    readonly distributionId: string;
+    readonly domainName: string;
+    readonly functionUrl?: lambda.FunctionUrl;
+    readonly host?: string;
+    readonly logBucket?: s3.IBucket;
+    constructor(scope: Construct, id: string, props: JaypieDistributionProps);
+    private isIOrigin;
+    private isIFunctionUrl;
+    private isIFunction;
+    get env(): {
+        account: string;
+        region: string;
+    };
+    get stack(): Stack;
+    applyRemovalPolicy(policy: RemovalPolicy): void;
+    grant(identity: import("aws-cdk-lib/aws-iam").IGrantable, ...actions: string[]): import("aws-cdk-lib/aws-iam").Grant;
+    grantCreateInvalidation(identity: import("aws-cdk-lib/aws-iam").IGrantable): import("aws-cdk-lib/aws-iam").Grant;
+    get distributionRef(): cloudfront.DistributionReference;
+}

package/dist/esm/JaypieDnsRecord.d.ts

@@ -0,0 +1,45 @@
+import * as cdk from "aws-cdk-lib";
+import { ARecord, CnameRecord, IHostedZone, MxRecord, NsRecord, TxtRecord } from "aws-cdk-lib/aws-route53";
+import { Construct } from "constructs";
+export interface JaypieDnsRecordProps {
+    /**
+     * Optional comment to add to the DNS record
+     */
+    comment?: string;
+    /**
+     * Optional record name (subdomain). If not provided, creates record at zone apex
+     */
+    recordName?: string;
+    /**
+     * Time to live for the DNS record
+     * @default CDK.DNS.CONFIG.TTL (5 minutes)
+     */
+    ttl?: cdk.Duration;
+    /**
+     * The DNS record type (A, CNAME, MX, NS, TXT)
+     */
+    type: string;
+    /**
+     * Values for the DNS record. Format depends on record type:
+     * - A: Array of IPv4 addresses (e.g., ["1.2.3.4", "5.6.7.8"])
+     * - CNAME: Single domain name as first element (e.g., ["example.com"])
+     * - MX: Array of objects with priority and hostName (e.g., [{priority: 10, hostName: "mail.example.com"}])
+     * - NS: Array of name server addresses (e.g., ["ns1.example.com", "ns2.example.com"])
+     * - TXT: Array of text values (e.g., ["v=spf1 include:example.com ~all"])
+     */
+    values: string[] | Array<{
+        hostName: string;
+        priority: number;
+    }>;
+    /**
+     * The hosted zone where the record will be created.
+     * Can be either:
+     * - A string (zone name) - will lookup the hosted zone by domain name
+     * - An IHostedZone object - will use the provided zone directly
+     */
+    zone: string | IHostedZone;
+}
+export declare class JaypieDnsRecord extends Construct {
+    readonly record: ARecord | CnameRecord | MxRecord | NsRecord | TxtRecord;
+    constructor(scope: Construct, id: string, props: JaypieDnsRecordProps);
+}

package/dist/esm/JaypieEnvSecret.d.ts

@@ -0,0 +1,41 @@
+import { Construct } from "constructs";
+import { SecretValue, RemovalPolicy, Stack } from "aws-cdk-lib";
+import * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
+import { ISecret, ISecretAttachmentTarget, RotationSchedule, RotationScheduleOptions } from "aws-cdk-lib/aws-secretsmanager";
+import { IKey } from "aws-cdk-lib/aws-kms";
+import { Grant, IGrantable, PolicyStatement, AddToResourcePolicyResult } from "aws-cdk-lib/aws-iam";
+export interface JaypieEnvSecretProps {
+    consumer?: boolean;
+    envKey?: string;
+    export?: string;
+    generateSecretString?: secretsmanager.SecretStringGenerator;
+    provider?: boolean;
+    roleTag?: string;
+    vendorTag?: string;
+    value?: string;
+}
+export declare class JaypieEnvSecret extends Construct implements ISecret {
+    private readonly _envKey?;
+    private readonly _secret;
+    constructor(scope: Construct, idOrEnvKey: string, props?: JaypieEnvSecretProps);
+    get stack(): Stack;
+    get env(): {
+        account: string;
+        region: string;
+    };
+    applyRemovalPolicy(policy: RemovalPolicy): void;
+    get secretArn(): string;
+    get secretName(): string;
+    get secretFullArn(): string | undefined;
+    get encryptionKey(): IKey | undefined;
+    get secretValue(): SecretValue;
+    secretValueFromJson(key: string): SecretValue;
+    grantRead(grantee: IGrantable, versionStages?: string[]): Grant;
+    grantWrite(grantee: IGrantable): Grant;
+    addRotationSchedule(id: string, options: RotationScheduleOptions): RotationSchedule;
+    addToResourcePolicy(statement: PolicyStatement): AddToResourcePolicyResult;
+    denyAccountRootDelete(): void;
+    attach(target: ISecretAttachmentTarget): ISecret;
+    cfnDynamicReferenceKey(options?: Parameters<ISecret["cfnDynamicReferenceKey"]>[0]): string;
+    get envKey(): string | undefined;
+}

package/dist/esm/JaypieEventsRule.d.ts

@@ -0,0 +1,45 @@
+import { Rule, RuleProps } from "aws-cdk-lib/aws-events";
+import { IFunction } from "aws-cdk-lib/aws-lambda";
+import { Construct } from "constructs";
+export interface JaypieEventsRuleProps extends Omit<RuleProps, "targets"> {
+    /**
+     * Optional construct ID
+     * @default Generated from source or "EventsRule"
+     */
+    id?: string;
+    /**
+     * Event source(s) to match
+     * @default undefined
+     */
+    source?: string | string[];
+    /**
+     * Lambda function to target
+     * Can be:
+     * - An IFunction instance
+     * - undefined (will resolve Datadog forwarder)
+     * @default Resolves Datadog forwarder via resolveDatadogForwarderFunction
+     */
+    targetFunction?: IFunction;
+    /**
+     * The service tag value
+     * @default CDK.SERVICE.DATADOG
+     */
+    service?: string;
+    /**
+     * The vendor tag value
+     * @default CDK.VENDOR.DATADOG
+     */
+    vendor?: string;
+    /**
+     * Optional project tag value
+     */
+    project?: string;
+}
+export declare class JaypieEventsRule extends Construct {
+    readonly rule: Rule;
+    readonly targetFunction: IFunction;
+    /**
+     * Create a new EventBridge rule that targets a Lambda function
+     */
+    constructor(scope: Construct, idOrSourceOrProps?: string | JaypieEventsRuleProps, propsOrUndefined?: JaypieEventsRuleProps);
+}

package/dist/esm/JaypieExpressLambda.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { JaypieLambda, JaypieLambdaProps } from "./JaypieLambda.js";
+export declare class JaypieExpressLambda extends JaypieLambda {
+    constructor(scope: Construct, id: string, props: JaypieLambdaProps);
+}

package/dist/esm/JaypieGitHubDeployRole.d.ts

@@ -0,0 +1,14 @@
+import { Role } from "aws-cdk-lib/aws-iam";
+import { Construct } from "constructs";
+export interface JaypieGitHubDeployRoleProps {
+    oidcProviderArn?: string;
+    output?: boolean | string;
+    repoRestriction?: string;
+}
+export declare class JaypieGitHubDeployRole extends Construct {
+    private readonly _role;
+    constructor(scope: Construct, id?: string, props?: JaypieGitHubDeployRoleProps);
+    get role(): Role;
+    get roleArn(): string;
+    get roleName(): string;
+}

package/dist/esm/JaypieHostedZone.d.ts

@@ -0,0 +1,59 @@
+import { ILogGroup } from "aws-cdk-lib/aws-logs";
+import { LambdaDestination } from "aws-cdk-lib/aws-logs-destinations";
+import { IHostedZone } from "aws-cdk-lib/aws-route53";
+import { Construct } from "constructs";
+import { JaypieDnsRecord, JaypieDnsRecordProps } from "./JaypieDnsRecord";
+/**
+ * DNS record configuration for JaypieHostedZone
+ * Omits 'zone' since it will be automatically set to the created hosted zone
+ */
+export interface JaypieHostedZoneRecordProps extends Omit<JaypieDnsRecordProps, "zone"> {
+    /**
+     * Optional ID for the DNS record construct
+     * @default Generated from record type and name
+     */
+    id?: string;
+}
+interface JaypieHostedZoneProps {
+    /**
+     * Optional construct ID
+     * @default `${zoneName}-HostedZone`
+     */
+    id?: string;
+    /**
+     * The domain name for the hosted zone
+     */
+    zoneName: string;
+    /**
+     * The service tag value
+     * @default CDK.SERVICE.INFRASTRUCTURE
+     */
+    service?: string;
+    /**
+     * Optional project tag value
+     */
+    project?: string;
+    /**
+     * Log destination configuration
+     * - LambdaDestination: Use a specific Lambda destination
+     * - true: Use Datadog logging destination (default)
+     * - false: Do not use a destination
+     * @default true
+     */
+    destination?: LambdaDestination | boolean;
+    /**
+     * Optional DNS records to create for this hosted zone
+     * Each record will be created as a JaypieDnsRecord construct
+     */
+    records?: JaypieHostedZoneRecordProps[];
+}
+export declare class JaypieHostedZone extends Construct {
+    readonly hostedZone: IHostedZone;
+    readonly logGroup: ILogGroup;
+    readonly dnsRecords: JaypieDnsRecord[];
+    /**
+     * Create a new hosted zone with query logging and optional DNS records
+     */
+    constructor(scope: Construct, idOrProps: string | JaypieHostedZoneProps, propsOrRecords?: JaypieHostedZoneProps | JaypieHostedZoneRecordProps[]);
+}
+export {};

package/dist/esm/JaypieInfrastructureStack.d.ts

@@ -0,0 +1,5 @@
+import { Construct } from "constructs";
+import { JaypieStack, JaypieStackProps } from "./JaypieStack";
+export declare class JaypieInfrastructureStack extends JaypieStack {
+    constructor(scope: Construct, id: string, props?: JaypieStackProps);
+}