@lafken/auth 0.10.1

package/lib/main/attribute/attribute.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Standard = exports.Custom = exports.Attributes = exports.authPayloadKey = exports.authFieldKey = void 0;
+require("reflect-metadata");
+const common_1 = require("@lafken/common");
+const extension_1 = require("../extension/extension");
+exports.authFieldKey = (0, common_1.createFieldName)(extension_1.RESOURCE_TYPE, common_1.FieldProperties.field);
+exports.authPayloadKey = (0, common_1.createFieldName)(extension_1.RESOURCE_TYPE, common_1.FieldProperties.payload);
+/**
+ * Class decorator that declares a class as a Cognito User Pool
+ * attributes definition.
+ *
+ * The decorated class groups standard and custom attributes that will
+ * be configured on the Cognito User Pool. Use `@Standard` and `@Custom`
+ * on its properties to describe each attribute.
+ *
+ * @param props - Optional payload configuration (e.g. a custom `name`).
+ *
+ * @example
+ * ```ts
+ * @Attributes()
+ * export class UserAttributes {
+ *   @Standard({ required: true })
+ *   email: string;
+ *
+ *   @Custom({ minLen: 2, maxLen: 50 })
+ *   displayName: string;
+ * }
+ * ```
+ */
+exports.Attributes = (0, common_1.createPayloadDecorator)({
+    prefix: extension_1.RESOURCE_TYPE,
+    createUniqueId: false,
+});
+/**
+ * Property decorator that registers a custom attribute on the Cognito
+ * User Pool.
+ *
+ * Custom attributes are user-defined fields that extend the default
+ * Cognito schema. The decorator options are resolved based on the
+ * property type: string fields accept `minLen` / `maxLen`, number fields
+ * accept `min` / `max`, and all types support `mutable`.
+ *
+ * @typeParam T - The class type that owns the decorated property.
+ * @typeParam A - The property key being decorated.
+ * @param props - Optional type-specific constraints for the attribute.
+ *
+ * @example
+ * ```ts
+ * @Attributes()
+ * export class UserAttributes {
+ *   @Custom({ minLen: 2, maxLen: 100 })
+ *   displayName: string;
+ *
+ *   @Custom({ min: 0, max: 200 })
+ *   score: number;
+ *
+ *   @Custom({ mutable: false })
+ *   isVerified: boolean;
+ * }
+ * ```
+ */
+const Custom = (props = {}) => (target, propertyName) => (0, common_1.createFieldDecorator)({
+    prefix: extension_1.RESOURCE_TYPE,
+    getMetadata: (props) => ({
+        ...props,
+        attributeType: 'custom',
+        mutable: props?.mutable ?? true,
+    }),
+})(props)(target, propertyName);
+exports.Custom = Custom;
+/**
+ * Property decorator that marks a field as a standard Cognito User Pool
+ * attribute.
+ *
+ * Standard attributes are predefined by Cognito and follow the OpenID
+ * Connect specification. The property name must match one of the
+ * supported attribute keys:
+ *
+ * `name`, `familyName`, `givenName`, `middleName`, `nickname`,
+ * `preferredUsername`, `profile`, `picture`, `website`, `gender`,
+ * `birthdate`, `zoneInfo`, `locale`, `updated_at`, `address`,
+ * `email`, `phoneNumber`, `sub`.
+ *
+ * @param props - Optional settings for the attribute.
+ * @param props.required - Whether the attribute is required during sign-up. Defaults to `true`.
+ * @param props.mutable - Whether the attribute value can be changed after creation. Defaults to `true`.
+ *
+ * @example
+ * ```ts
+ * @Attributes()
+ * export class UserAttributes {
+ *   @Standard({ required: true })
+ *   email: string;
+ *
+ *   @Standard({ required: false, mutable: true })
+ *   nickname: string;
+ * }
+ * ```
+ */
+const Standard = (props = {}) => (target, propertyKey) => (0, common_1.createFieldDecorator)({
+    prefix: extension_1.RESOURCE_TYPE,
+    getMetadata: (props) => ({
+        attributeType: 'standard',
+        mutable: props?.mutable ?? true,
+        required: props?.required ?? true,
+    }),
+})(props)(target, propertyKey);
+exports.Standard = Standard;

package/lib/main/attribute/attribute.types.d.ts

@@ -0,0 +1,90 @@
+import type { FieldMetadata, FieldProps } from '@lafken/common';
+/**
+ * Metadata keys used internally to store Cognito attribute
+ * information via `Reflect.defineMetadata`.
+ */
+export declare enum CognitoPropertyReflectKeys {
+    custom = "cognito:custom-attribute",
+    standard = "cognito:standard-attribute",
+    PAYLOAD = "cognito:payload"
+}
+/**
+ * Base options shared by all custom Cognito attributes.
+ */
+interface CommonCustomAttribute extends Omit<FieldProps, 'type'> {
+    /**
+     * Whether the attribute value can be changed after the user is created.
+     * Defaults to `true`.
+     */
+    mutable?: boolean;
+    /**
+     * The data type of the attribute. Accepted values are `String`,
+     * `Number`, or `Boolean`.
+     */
+    type?: String | Number | Boolean;
+}
+/**
+ * Options for a standard Cognito attribute.
+ */
+export interface CommonStandardAttribute extends Omit<CommonCustomAttribute, 'name'> {
+    /**
+     * Whether the attribute is required during user sign-up.
+     * Defaults to `true`.
+     */
+    required?: boolean;
+}
+/**
+ * Resolved metadata stored for a standard attribute after the
+ * `@Standard` decorator is processed.
+ */
+export type StandardAttributeMetadata = Required<CommonStandardAttribute> & FieldMetadata & {
+    attributeType: 'standard';
+};
+/**
+ * Options for a custom attribute whose property type is `number`.
+ */
+export interface NumberCustomAttribute extends CommonCustomAttribute {
+    /** Minimum allowed value. */
+    min?: number;
+    /** Maximum allowed value. */
+    max?: number;
+}
+/**
+ * Options for a custom attribute whose property type is `string`.
+ */
+export interface StringCustomAttribute extends CommonCustomAttribute {
+    /** Minimum string length. */
+    minLen?: number;
+    /** Maximum string length. */
+    maxLen?: number;
+}
+export interface AuthAttributes {
+    name?: string;
+    familyName?: string;
+    givenName?: string;
+    middleName?: string;
+    nickname?: string;
+    preferredUsername?: string;
+    profile?: string;
+    picture?: string;
+    website?: string;
+    gender?: string;
+    birthdate?: Date;
+    zoneInfo?: string;
+    locale?: string;
+    updated_at?: string;
+    address?: string;
+    email?: string;
+    phoneNumber?: string;
+    sub?: string;
+}
+export type CustomAttributeProps<T> = T extends number ? NumberCustomAttribute : T extends string ? StringCustomAttribute : CommonCustomAttribute;
+export type CustomAttributesMetadata = FieldMetadata & {
+    attributeType: 'custom';
+    mutable: boolean;
+    min?: number;
+    max?: number;
+    minLen?: number;
+    maxLen?: number;
+};
+export {};

package/lib/main/attribute/attribute.types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CognitoPropertyReflectKeys = void 0;
+/**
+ * Metadata keys used internally to store Cognito attribute
+ * information via `Reflect.defineMetadata`.
+ */
+var CognitoPropertyReflectKeys;
+(function (CognitoPropertyReflectKeys) {
+    CognitoPropertyReflectKeys["custom"] = "cognito:custom-attribute";
+    CognitoPropertyReflectKeys["standard"] = "cognito:standard-attribute";
+    CognitoPropertyReflectKeys["PAYLOAD"] = "cognito:payload";
+})(CognitoPropertyReflectKeys || (exports.CognitoPropertyReflectKeys = CognitoPropertyReflectKeys = {}));

package/lib/main/attribute/index.d.ts

@@ -0,0 +1,2 @@
+export * from './attribute';
+export * from './attribute.types';

package/lib/main/attribute/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./attribute"), exports);
+__exportStar(require("./attribute.types"), exports);

package/lib/main/event/event.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parameter decorator that binds the incoming Cognito trigger event
+ * to a handler method argument.
+ *
+ * Use it on a `@Trigger` handler parameter so the framework
+ * automatically injects the raw Cognito event object at runtime.
+ *
+ * @example
+ * ```ts
+ * @AuthExtension()
+ * export class AuthTriggers {
+ *   @Trigger({ type: 'preSignUp' })
+ *   onPreSignUp(@Event() event: PreSignUpTriggerEvent) {
+ *     // event contains the Cognito trigger payload
+ *   }
+ * }
+ * ```
+ */
+export declare const Event: () => (target: any, methodName: string, _number: number) => void;

package/lib/main/event/event.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Event = void 0;
+const common_1 = require("@lafken/common");
+const extension_1 = require("../extension/extension");
+/**
+ * Parameter decorator that binds the incoming Cognito trigger event
+ * to a handler method argument.
+ *
+ * Use it on a `@Trigger` handler parameter so the framework
+ * automatically injects the raw Cognito event object at runtime.
+ *
+ * @example
+ * ```ts
+ * @AuthExtension()
+ * export class AuthTriggers {
+ *   @Trigger({ type: 'preSignUp' })
+ *   onPreSignUp(@Event() event: PreSignUpTriggerEvent) {
+ *     // event contains the Cognito trigger payload
+ *   }
+ * }
+ * ```
+ */
+const Event = () => (0, common_1.createEventDecorator)({ prefix: extension_1.RESOURCE_TYPE })(class {
+});
+exports.Event = Event;

package/lib/main/extension/extension.d.ts

@@ -0,0 +1,60 @@
+import type { ExtensionsProps, TriggerProps } from './extension.types';
+export declare const RESOURCE_TYPE: "AUTHENTICATION";
+/**
+ * Class decorator that registers a class as a Cognito authentication
+ * extension resource.
+ *
+ * The decorated class groups one or more `@Trigger` handlers that
+ * respond to Cognito User Pool lifecycle events (e.g. pre sign-up,
+ * post confirmation, custom message, etc.).
+ *
+ * @param props - Optional configuration.
+ * @param props.name - A custom name for the resource.
+ *
+ * @example
+ * ```ts
+ * @AuthExtension()
+ * export class AuthTriggers {
+ *   @Trigger({ type: 'preSignUp' })
+ *   onPreSignUp(@Event() event) { }
+ *
+ *   @Trigger({ type: 'postConfirmation' })
+ *   onPostConfirmation(@Event() event) { }
+ * }
+ * ```
+ */
+export declare const AuthExtension: (props?: ExtensionsProps) => (constructor: Function) => void;
+/**
+ * Method decorator that registers a handler for a specific Cognito
+ * User Pool trigger.
+ *
+ * Each decorated method becomes a Lambda function that Cognito invokes
+ * during the corresponding lifecycle event. Supported trigger types:
+ *
+ * `preSignUp`, `preAuthentication`, `preTokenGeneration`,
+ * `preTokenGenerationConfig`, `userMigration`, `postAuthentication`,
+ * `postConfirmation`, `createAuthChallenge`, `defineAuthChallenge`,
+ * `customMessage`, `customEmailSender`, `customSmsSender`,
+ * `verifyAuthChallengeResponse`.
+ *
+ * @param props - Trigger configuration.
+ * @param props.type - The Cognito trigger type to handle.
+ * @param props.lambda - Optional Lambda settings (memory, timeout, etc.).
+ *
+ * @example
+ * ```ts
+ * @AuthExtension()
+ * export class AuthTriggers {
+ *   @Trigger({ type: 'preSignUp' })
+ *   validateSignUp(@Event() event) {
+ *     // validate and return event
+ *   }
+ *
+ *   @Trigger({ type: 'customMessage', lambda: { memory: 512 } })
+ *   customEmail(@Event() event) {
+ *     // customize the email message
+ *   }
+ * }
+ * ```
+ */
+export declare const Trigger: (props: TriggerProps) => (target: any, methodName: string, descriptor: PropertyDescriptor) => any;

package/lib/main/extension/extension.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trigger = exports.AuthExtension = exports.RESOURCE_TYPE = void 0;
+const common_1 = require("@lafken/common");
+exports.RESOURCE_TYPE = 'AUTHENTICATION';
+/**
+ * Class decorator that registers a class as a Cognito authentication
+ * extension resource.
+ *
+ * The decorated class groups one or more `@Trigger` handlers that
+ * respond to Cognito User Pool lifecycle events (e.g. pre sign-up,
+ * post confirmation, custom message, etc.).
+ *
+ * @param props - Optional configuration.
+ * @param props.name - A custom name for the resource.
+ *
+ * @example
+ * ```ts
+ * @AuthExtension()
+ * export class AuthTriggers {
+ *   @Trigger({ type: 'preSignUp' })
+ *   onPreSignUp(@Event() event) { }
+ *
+ *   @Trigger({ type: 'postConfirmation' })
+ *   onPostConfirmation(@Event() event) { }
+ * }
+ * ```
+ */
+const AuthExtension = (props) => (0, common_1.createResourceDecorator)({
+    callerFileIndex: 5,
+    type: exports.RESOURCE_TYPE,
+    getMetadata: (props) => props,
+})(props);
+exports.AuthExtension = AuthExtension;
+/**
+ * Method decorator that registers a handler for a specific Cognito
+ * User Pool trigger.
+ *
+ * Each decorated method becomes a Lambda function that Cognito invokes
+ * during the corresponding lifecycle event. Supported trigger types:
+ *
+ * `preSignUp`, `preAuthentication`, `preTokenGeneration`,
+ * `preTokenGenerationConfig`, `userMigration`, `postAuthentication`,
+ * `postConfirmation`, `createAuthChallenge`, `defineAuthChallenge`,
+ * `customMessage`, `customEmailSender`, `customSmsSender`,
+ * `verifyAuthChallengeResponse`.
+ *
+ * @param props - Trigger configuration.
+ * @param props.type - The Cognito trigger type to handle.
+ * @param props.lambda - Optional Lambda settings (memory, timeout, etc.).
+ *
+ * @example
+ * ```ts
+ * @AuthExtension()
+ * export class AuthTriggers {
+ *   @Trigger({ type: 'preSignUp' })
+ *   validateSignUp(@Event() event) {
+ *     // validate and return event
+ *   }
+ *
+ *   @Trigger({ type: 'customMessage', lambda: { memory: 512 } })
+ *   customEmail(@Event() event) {
+ *     // customize the email message
+ *   }
+ * }
+ * ```
+ */
+const Trigger = (props) => (0, common_1.createLambdaDecorator)({
+    getLambdaMetadata: (props, name) => ({
+        name,
+        ...props,
+    }),
+})(props);
+exports.Trigger = Trigger;

package/lib/main/extension/extension.types.d.ts

@@ -0,0 +1,37 @@
+import type { LambdaMetadata, LambdaProps, ResourceMetadata } from '@lafken/common';
+/**
+ * Supported Cognito User Pool trigger types.
+ *
+ * Each value corresponds to a lifecycle event that Cognito can invoke
+ * a Lambda function for during user authentication and management flows.
+ */
+export type TriggerType = 'preAuthentication' | 'preSignUp' | 'preTokenGeneration' | 'preTokenGenerationConfig' | 'userMigration' | 'postAuthentication' | 'postConfirmation' | 'createAuthChallenge' | 'defineAuthChallenge' | 'customMessage' | 'customEmailSender' | 'customSmsSender' | 'verifyAuthChallengeResponse';
+/**
+ * Configuration options for the `@AuthExtension` class decorator.
+ */
+export interface ExtensionsProps {
+    /**
+     * A custom name for the authentication extension resource.
+     * If omitted, the class name is used by default.
+     */
+    name?: string;
+}
+export interface ExtensionsMetadata extends ResourceMetadata {
+}
+/**
+ * Configuration options for the `@Trigger` method decorator.
+ */
+export interface TriggerProps {
+    /**
+     * Optional Lambda function settings applied to the trigger handler
+     * (e.g. memory, timeout, runtime, environment variables).
+     */
+    lambda?: LambdaProps;
+    /**
+     * The Cognito User Pool trigger type this handler responds to.
+     */
+    type: TriggerType;
+}
+export interface TriggerMetadata extends LambdaMetadata {
+    type: TriggerType;
+}

package/lib/main/extension/extension.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/main/extension/index.d.ts

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

package/lib/main/extension/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/main/index.d.ts

@@ -0,0 +1 @@
+export * from './attribute';

package/lib/main/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./attribute"), exports);

package/lib/resolver/auth/auth.d.ts

@@ -0,0 +1,11 @@
+import { Construct } from 'constructs';
+import type { AuthOptions } from '../resolver.types';
+export declare class Auth extends Construct {
+    private id;
+    private props;
+    private userPool;
+    private userPoolClient;
+    constructor(scope: Construct, id: string, props: AuthOptions<any>);
+    create(): Promise<void>;
+    callExtends(): Promise<void>;
+}

package/lib/resolver/auth/auth.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Auth = void 0;
+const constructs_1 = require("constructs");
+const external_1 = require("./user-pool/external/external");
+const internal_1 = require("./user-pool/internal/internal");
+const external_2 = require("./user-pool-client/external/external");
+const internal_2 = require("./user-pool-client/internal/internal");
+class Auth extends constructs_1.Construct {
+    id;
+    props;
+    userPool;
+    userPoolClient;
+    constructor(scope, id, props) {
+        super(scope, `${id}-auth`);
+        this.id = id;
+        this.props = props;
+    }
+    async create() {
+        if (this.props.userPool?.isExternal) {
+            this.userPool = new external_1.ExternalUserPool(this, this.id, this.props.userPool);
+        }
+        else {
+            this.userPool = new internal_1.InternalUserPool(this, this.id, this.props.userPool || {});
+        }
+        if (this.props.userClient?.isExternal) {
+            this.userPoolClient = new external_2.ExternalUserPoolClient(this, this.id, {
+                userPoolId: this.userPool.id,
+                ...this.props.userClient,
+            });
+        }
+        else {
+            this.userPoolClient = new internal_2.InternalUserPoolClient(this, this.id, {
+                userPoolId: this.userPool.id,
+                ...this.props.userClient,
+                attributeByName: this.userPool instanceof internal_1.InternalUserPool ? this.userPool.attributeByName : {},
+            });
+        }
+    }
+    async callExtends() {
+        if (this.props.extend) {
+            await this.props.extend({
+                scope: this,
+                userPool: this.userPool,
+                userPoolClient: this.userPoolClient.cognitoUserPoolClient,
+            });
+        }
+    }
+}
+exports.Auth = Auth;

package/lib/resolver/auth/auth.utils.d.ts

@@ -0,0 +1,2 @@
+import type { AuthAttributes } from '../../main';
+export declare const mapUserAttributes: Record<keyof AuthAttributes, string>;

package/lib/resolver/auth/auth.utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapUserAttributes = void 0;
+exports.mapUserAttributes = {
+    name: 'name',
+    familyName: 'family_name',
+    givenName: 'given_name',
+    middleName: 'middle_name',
+    nickname: 'nickname',
+    preferredUsername: 'preferred_username',
+    profile: 'profile',
+    picture: 'picture',
+    website: 'website',
+    gender: 'gender',
+    birthdate: 'birthdate',
+    zoneInfo: 'zoneinfo',
+    locale: 'locale',
+    updated_at: 'updated_at',
+    address: 'address',
+    email: 'email',
+    phoneNumber: 'phone_number',
+    sub: 'sub',
+};

package/lib/resolver/auth/user-pool/extension/extension.d.ts

@@ -0,0 +1,8 @@
+import type { CognitoUserPoolLambdaConfig } from '@cdktn/provider-aws/lib/cognito-user-pool';
+import { Construct } from 'constructs';
+import type { ExtensionProps } from './extension.types';
+export declare class Extension extends Construct {
+    props: ExtensionProps;
+    constructor(scope: Construct, id: string, props: ExtensionProps);
+    createTriggers(userPoolArn: string): CognitoUserPoolLambdaConfig;
+}

package/lib/resolver/auth/user-pool/extension/extension.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Extension = void 0;
+const resolver_1 = require("@lafken/resolver");
+const constructs_1 = require("constructs");
+class Extension extends constructs_1.Construct {
+    props;
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+    }
+    createTriggers(userPoolArn) {
+        const triggers = {};
+        const { handlers, resourceMetadata } = this.props;
+        for (const handler of handlers) {
+            const lambdaHandler = new resolver_1.LambdaHandler(this, `${handler.name}-${resourceMetadata.name}`, {
+                ...handler,
+                originalName: resourceMetadata.originalName,
+                filename: resourceMetadata.filename,
+                foldername: resourceMetadata.foldername,
+                principal: 'cognito-idp.amazonaws.com',
+                suffix: 'auth',
+                sourceArn: userPoolArn,
+            });
+            switch (handler.type) {
+                case 'customEmailSender':
+                    triggers.customEmailSender = {
+                        lambdaArn: lambdaHandler.arn,
+                        lambdaVersion: 'V1_0',
+                    };
+                    break;
+                case 'customSmsSender':
+                    triggers.customSmsSender = {
+                        lambdaArn: lambdaHandler.arn,
+                        lambdaVersion: 'V1_0',
+                    };
+                    break;
+                case 'preTokenGenerationConfig':
+                    triggers.preTokenGenerationConfig = {
+                        lambdaArn: lambdaHandler.arn,
+                        lambdaVersion: 'V1_0',
+                    };
+                    break;
+                default:
+                    triggers[handler.type] = lambdaHandler.arn;
+            }
+        }
+        return triggers;
+    }
+}
+exports.Extension = Extension;

package/lib/resolver/auth/user-pool/extension/extension.types.d.ts

@@ -0,0 +1,6 @@
+import type { ResourceMetadata } from '@lafken/common';
+import type { TriggerMetadata } from '../../../../main/extension/extension.types';
+export interface ExtensionProps {
+    resourceMetadata: ResourceMetadata;
+    handlers: TriggerMetadata[];
+}

package/lib/resolver/auth/user-pool/extension/extension.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/resolver/auth/user-pool/external/external.d.ts

@@ -0,0 +1,14 @@
+import { DataAwsCognitoUserPool } from '@cdktn/provider-aws/lib/data-aws-cognito-user-pool';
+import type { Construct } from 'constructs';
+import type { ExternalUserPoolProps } from '../user-pool.types';
+declare const ExternalUserPool_base: (new (...args: any[]) => {
+    isGlobal(module: import("@lafken/common").ModuleGlobalReferenceNames | (string & {}), id: string): void;
+    isDependent(resolveDependency: () => void): void;
+    readonly node: import("constructs").Node;
+    with(...mixins: import("constructs").IMixin[]): import("constructs").IConstruct;
+    toString(): string;
+}) & typeof DataAwsCognitoUserPool;
+export declare class ExternalUserPool extends ExternalUserPool_base {
+    constructor(scope: Construct, id: string, props: ExternalUserPoolProps);
+}
+export {};