@kaapi/oauth2-auth-design 0.0.35 → 0.0.36

package/lib/generators/oauth2-flow-generator.js

@@ -0,0 +1,606 @@
+"use strict";
+var _OAuth2FlowGenerator_instances, _OAuth2FlowGenerator_values, _OAuth2FlowGenerator_getOidcAuthCodeContent, _OAuth2FlowGenerator_getOidcClientCredentialsContent, _OAuth2FlowGenerator_getOidcDeviceAuthContent;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuth2FlowGenerator = void 0;
+const tslib_1 = require("tslib");
+const definitions_1 = require("@kaapi/cli/definitions");
+const utils_1 = require("@kaapi/cli/utils");
+var FLOW_ENUM;
+(function (FLOW_ENUM) {
+    FLOW_ENUM["oidcAuthCode"] = "oidc-auth-code";
+    FLOW_ENUM["oidcClientCredentials"] = "oidc-client-credentials";
+    FLOW_ENUM["oidcDeviceAuth"] = "oidc-device-auth";
+})(FLOW_ENUM || (FLOW_ENUM = {}));
+const FLOW_OPTIONS = [
+    {
+        value: FLOW_ENUM.oidcAuthCode,
+        label: 'OIDC Authorization Code',
+        hint: ''
+    },
+    {
+        value: FLOW_ENUM.oidcClientCredentials,
+        label: 'OIDC Client Credentials',
+        hint: ''
+    },
+    {
+        value: FLOW_ENUM.oidcDeviceAuth,
+        label: 'OIDC Device Authorization',
+        hint: ''
+    }
+];
+class OAuth2FlowGenerator {
+    constructor() {
+        _OAuth2FlowGenerator_instances.add(this);
+        _OAuth2FlowGenerator_values.set(this, {
+            name: '',
+            flow: ''
+        });
+    }
+    get type() {
+        return 'auth-design';
+    }
+    get name() {
+        return 'oauth2-flow';
+    }
+    get description() {
+        return 'Creates an auth design based on OAuth2 specifications.';
+    }
+    get notes() {
+        return [
+            'Allowed values for --flow:',
+            ...FLOW_OPTIONS.map(o => `  - ${o.value}`)
+        ];
+    }
+    get options() {
+        return {
+            name: 'The name of the strategy',
+            flow: 'The grant type flow'
+        };
+    }
+    init(options) {
+        if (typeof options['name'] == 'string') {
+            tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").name = (0, utils_1.camelCase)(options['name']);
+        }
+        if (typeof options['flow'] == 'string') {
+            if (!FLOW_OPTIONS.map(v => v.value).includes(options['flow'])) {
+                throw new Error(`Invalid value for '--flow'. Allowed values are: ${FLOW_OPTIONS.map(v => v.value).join(', ')}.`);
+            }
+            tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").flow = options['flow'];
+        }
+    }
+    isValid() {
+        return !!tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").name;
+    }
+    getFileContent() {
+        if (tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").flow === FLOW_ENUM.oidcAuthCode)
+            return tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_instances, "m", _OAuth2FlowGenerator_getOidcAuthCodeContent).call(this);
+        else if (tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").flow === FLOW_ENUM.oidcClientCredentials)
+            return tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_instances, "m", _OAuth2FlowGenerator_getOidcClientCredentialsContent).call(this);
+        else if (tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").flow === FLOW_ENUM.oidcDeviceAuth)
+            return tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_instances, "m", _OAuth2FlowGenerator_getOidcDeviceAuthContent).call(this);
+        else
+            return '';
+    }
+    getQuestions() {
+        const r = [];
+        if (!tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").name) {
+            r.push({
+                type: definitions_1.QuestionType.text,
+                options: {
+                    message: 'The name of the strategy?',
+                    defaultValue: 'oauth2-strategy',
+                    placeholder: 'oauth2-strategy'
+                },
+                setValue: (value) => {
+                    tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").name = (0, utils_1.camelCase)(value);
+                }
+            });
+        }
+        if (!(tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").flow && FLOW_OPTIONS.map(v => v.value).includes(tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").flow))) {
+            r.push({
+                type: definitions_1.QuestionType.select,
+                options: {
+                    message: 'The authorization flow?',
+                    options: FLOW_OPTIONS,
+                    initialValue: 'oidc-auth-code'
+                },
+                setValue: (value) => {
+                    tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").flow = `${value}`;
+                }
+            });
+        }
+        return r;
+    }
+    getFilename() {
+        return (0, utils_1.kebabCase)(`${tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").name}`) + '.ts';
+    }
+}
+exports.OAuth2FlowGenerator = OAuth2FlowGenerator;
+_OAuth2FlowGenerator_values = new WeakMap(), _OAuth2FlowGenerator_instances = new WeakSet(), _OAuth2FlowGenerator_getOidcAuthCodeContent = function _OAuth2FlowGenerator_getOidcAuthCodeContent() {
+    return `// generated by @kaapi/oauth2-auth-design
+
+import {
+    BearerToken,
+    OIDCAuthorizationCodeBuilder,
+    createInMemoryKeyStore,
+    createMatchAuthCodeResult,
+    OAuth2TokenResponse,
+    ClientSecretBasic,
+    ClientSecretPost,
+    NoneAuthMethod,
+    OAuth2ErrorCode,
+} from '@kaapi/oauth2-auth-design';
+
+const VALID_CLIENTS = [
+    {
+        client_id: 'service-api-client',
+        client_secret: 's3cr3tK3y123!',
+        allowed_scopes: ['openid', 'profile', 'email', 'read', 'write'],
+    },
+];
+
+const REGISTERED_USERS = [{ id: 'user-1234', username: 'user', password: 'password', email: 'user@email.com' }];
+
+const authCodesStore: Map<
+    string,
+    { clientId: string; scopes: string[]; userId: string; codeChallenge?: string | undefined }
+> = new Map();
+
+export const oidcAuthCodeBuilder = OIDCAuthorizationCodeBuilder.create()
+    // the name of the strategy
+    .strategyName('${(0, utils_1.kebabCase)(tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").name)}')
+    // access token TTL (used in generateToken controller)
+    .setTokenTtl(3600)
+    // activate auto parsing of access token (jwtAccessTokenPayload + createJwtAccessToken)
+    .useAccessTokenJwks(true)
+    // Client authentication methods
+    .addClientAuthenticationMethod(new ClientSecretBasic())
+    .addClientAuthenticationMethod(new ClientSecretPost())
+    .addClientAuthenticationMethod(new NoneAuthMethod())
+    .setTokenType(new BearerToken())
+    // Define scopes
+    .setScopes({
+        profile: 'Access to basic profile information such as name and picture.',
+        email: "Access to the user's email address and its verification status.",
+        read: 'Grants read-only access to protected resources',
+        write: 'Grants write access to protected resources',
+    })
+
+    // Authorization
+    .authorizationRoute<object, { Payload: { username?: string; password?: string } }>((route) =>
+        route
+            .setPath('/oauth2/v1.0/authorize')
+            .setUsernameField('username')
+            .setPasswordField('password')
+            .generateCode(async ({ clientId, codeChallenge, scope }, req, _h) => {
+                // client exists?
+                const client = VALID_CLIENTS.find((c) => c.client_id === clientId);
+                if (!client) return null;
+
+                // filter client's allowed scoped
+                const requestedScopes = (scope ?? '').split(/\\s+/).filter(Boolean);
+                const grantedScopes = requestedScopes.length
+                    ? requestedScopes.filter((s) => client.allowed_scopes.includes(s))
+                    : client.allowed_scopes;
+                if (grantedScopes.length === 0) return null;
+
+                // user exists?
+                const user = REGISTERED_USERS.find(
+                    (u) => u.username === req.payload.username && u.password === req.payload.password
+                );
+                if (!user) return null;
+
+                // generate code
+                const code = \`auth-${Date.now()}\`;
+                authCodesStore.set(code, { clientId, scopes: grantedScopes, userId: user.id, codeChallenge });
+                return { type: 'code', value: code };
+            })
+            .finalizeAuthorization(async (ctx, _params, _req, h) => {
+                // redirect to callback url (could do something else depending on the code result)
+                const matcher = createMatchAuthCodeResult({
+                    code: async () => h.redirect(ctx.fullRedirectUri),
+                    continue: async () => h.redirect(ctx.fullRedirectUri),
+                    deny: async () => h.redirect(ctx.fullRedirectUri),
+                });
+                return matcher(ctx.authorizationResult);
+            })
+    )
+
+    // Token exchange
+    .tokenRoute((route) =>
+        route.generateToken(
+            async ({
+                clientId,
+                ttl,
+                tokenType,
+                code,
+                clientSecret,
+                codeVerifier,
+                createJwtAccessToken,
+                createIdToken,
+                verifyCodeVerifier,
+            }) => {
+                const entry = authCodesStore.get(code);
+                if (!entry || entry.clientId !== clientId) return null;
+
+                const client = VALID_CLIENTS.find((c) => c.client_id === clientId);
+                if (!client) {
+                    return {
+                        error: OAuth2ErrorCode.INVALID_CLIENT,
+                        error_description: 'Client authentication failed.',
+                    };
+                }
+
+                if (entry.codeChallenge && codeVerifier) {
+                    if (!verifyCodeVerifier(codeVerifier, entry.codeChallenge)) {
+                        return {
+                            error: OAuth2ErrorCode.INVALID_GRANT,
+                            error_description: 'Invalid authorization grant.',
+                        };
+                    }
+                } else if (clientSecret) {
+                    if (client.client_secret !== clientSecret) {
+                        return {
+                            error: OAuth2ErrorCode.INVALID_CLIENT,
+                            error_description: 'Client authentication failed.',
+                        };
+                    }
+                } else {
+                    return {
+                        error: OAuth2ErrorCode.INVALID_REQUEST,
+                        error_description: 'Missing or invalid request parameter.',
+                    };
+                }
+
+                const user = REGISTERED_USERS.find((u) => u.id === entry.userId);
+                if (!user) {
+                    return {
+                        error: OAuth2ErrorCode.INVALID_GRANT,
+                        error_description: 'Invalid authorization grant.',
+                    };
+                }
+
+                // Generate a signed JWT access token
+                const { token: accessToken } = await createJwtAccessToken!({
+                    sub: entry.userId,
+                    client_id: clientId,
+                    scope: entry.scopes,
+                });
+
+                // Generate a signed JWT id token
+                const idToken = entry.scopes.includes('openid')
+                    ? (await createIdToken!({ sub: entry.userId, name: user.username, aud: clientId })).token
+                    : undefined;
+
+                // Return token response
+                return new OAuth2TokenResponse({ access_token: accessToken })
+                    .setExpiresIn(ttl)
+                    .setTokenType(tokenType)
+                    .setScope(entry.scopes)
+                    .setIdToken(idToken);
+            }
+        )
+    )
+
+    // Access Token Validation
+    .validate(async (_req, { jwtAccessTokenPayload }) => {
+        if (!jwtAccessTokenPayload?.sub) return { isValid: false };
+        return {
+            isValid: true,
+            credentials: {
+                user: {
+                    id: jwtAccessTokenPayload.sub,
+                    clientId: jwtAccessTokenPayload.client_id,
+                },
+                scope: Array.isArray(jwtAccessTokenPayload.scope) ? jwtAccessTokenPayload.scope : [],
+            },
+        };
+    })
+        
+    // JWKS
+    .jwksRoute((route) => route.setPath('/discovery/v1.0/keys')) // activates jwks uri
+    .setPublicKeyExpiry(86400) // 24h
+    .setJwksKeyStore(createInMemoryKeyStore()) // store for JWKS
+    .setJwksRotatorOptions({
+        intervalMs: 7.884e9, // 91 days
+        timestampStore: createInMemoryKeyStore(),
+    });
+`;
+}, _OAuth2FlowGenerator_getOidcClientCredentialsContent = function _OAuth2FlowGenerator_getOidcClientCredentialsContent() {
+    return `// generated by @kaapi/oauth2-auth-design
+
+import {
+    OIDCClientCredentialsBuilder,
+    OAuth2TokenResponse,
+    OAuth2ErrorCode,
+    ClientSecretBasic,
+    ClientSecretPost,
+    BearerToken,
+    createInMemoryKeyStore,
+} from '@kaapi/oauth2-auth-design';
+
+const VALID_CLIENTS = [
+    {
+        client_id: 'internal-service',
+        client_secret: 'Int3rnalK3y!',
+        allowed_scopes: ['read', 'write', 'admin'],
+    },
+];
+
+export const oidcClientCredentialsBuilder = OIDCClientCredentialsBuilder.create()
+    // the name of the strategy
+    .strategyName('${(0, utils_1.kebabCase)(tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").name)}')
+    // access token ttl (used in generateToken controller)
+    .setTokenTtl(600)
+    // activate auto parsing of access token (jwtAccessTokenPayload + createJwtAccessToken)
+    .useAccessTokenJwks(true)
+    // Client authentication methods
+    .addClientAuthenticationMethod(new ClientSecretBasic())
+    .addClientAuthenticationMethod(new ClientSecretPost())
+    .setTokenType(new BearerToken())
+    // Define available scopes
+    .setScopes({
+        read: 'Grants read-only access to protected resources',
+        write: 'Grants write access to protected resources',
+        admin: 'Administrative access',
+    })
+
+    // Token exchange
+    .tokenRoute((route) =>
+        route.generateToken(async ({ clientId, clientSecret, ttl, tokenType, scope, createJwtAccessToken }) => {
+            // Validate client credentials
+            const client = VALID_CLIENTS.find((c) => c.client_id === clientId && c.client_secret === clientSecret);
+
+            if (!client) {
+                return {
+                    error: OAuth2ErrorCode.INVALID_CLIENT,
+                    error_description: 'Invalid client_id or client_secret',
+                };
+            }
+
+            // Determine requested scopes
+            const requestedScopes = (scope ?? '').split(/\\s+/).filter(Boolean);
+
+            // Compute granted scopes
+            let grantedScopes = client.allowed_scopes;
+            if (requestedScopes.length > 0) {
+                grantedScopes = requestedScopes.filter((s) => client.allowed_scopes.includes(s));
+            }
+
+            if (grantedScopes.length === 0) {
+                return {
+                    error: OAuth2ErrorCode.INVALID_SCOPE,
+                    error_description: 'No valid scopes granted for this client',
+                };
+            }
+
+            // Generate a signed JWT access token
+            const { token: accessToken } = await createJwtAccessToken!({
+                sub: clientId,
+                app: true,
+                scope: grantedScopes,
+            });
+
+            // Return token response
+            return new OAuth2TokenResponse({ access_token: accessToken })
+                .setExpiresIn(ttl)
+                .setTokenType(tokenType)
+                .setScope(grantedScopes.join(' '));
+        })
+    )
+
+    // Access Token Validation
+    .validate(async (_req, { jwtAccessTokenPayload }) => {
+        if (!jwtAccessTokenPayload?.sub || !jwtAccessTokenPayload.app) return { isValid: false };
+        return {
+            isValid: true,
+            credentials: {
+                app: {
+                    id: jwtAccessTokenPayload.sub,
+                },
+                scope: Array.isArray(jwtAccessTokenPayload.scope) ? jwtAccessTokenPayload.scope : [],
+            },
+        };
+    })
+
+    // JWKS
+    .jwksRoute((route) => route.setPath('/discovery/v1.0/keys')) // activates jwks uri
+    .setPublicKeyExpiry(86400) // 24h
+    .setJwksKeyStore(createInMemoryKeyStore()) // store for JWKS
+    .setJwksRotatorOptions({
+        intervalMs: 7.884e9, // 91 days
+        timestampStore: createInMemoryKeyStore(),
+    });
+`;
+}, _OAuth2FlowGenerator_getOidcDeviceAuthContent = function _OAuth2FlowGenerator_getOidcDeviceAuthContent() {
+    return `// generated by @kaapi/oauth2-auth-design
+
+import {
+    BearerToken,
+    OIDCAuthorizationCodeBuilder,
+    createInMemoryKeyStore,
+    createMatchAuthCodeResult,
+    OAuth2TokenResponse,
+    ClientSecretBasic,
+    ClientSecretPost,
+    NoneAuthMethod,
+    OAuth2ErrorCode,
+} from '@kaapi/oauth2-auth-design';
+
+const VALID_CLIENTS = [
+    {
+        client_id: 'service-api-client',
+        client_secret: 's3cr3tK3y123!',
+        allowed_scopes: ['openid', 'profile', 'email', 'read', 'write'],
+    },
+];
+
+const REGISTERED_USERS = [{ id: 'user-1234', username: 'user', password: 'password', email: 'user@email.com' }];
+
+const authCodesStore: Map<
+    string,
+    { clientId: string; scopes: string[]; userId: string; codeChallenge?: string | undefined }
+> = new Map();
+
+export const oidcAuthCodeBuilder = OIDCAuthorizationCodeBuilder.create()
+    // the name of the strategy
+    .strategyName('${(0, utils_1.kebabCase)(tslib_1.__classPrivateFieldGet(this, _OAuth2FlowGenerator_values, "f").name)}')
+    // access token TTL (used in generateToken controller)
+    .setTokenTtl(3600)
+    // activate auto parsing of access token (jwtAccessTokenPayload + createJwtAccessToken)
+    .useAccessTokenJwks(true)
+    // Client authentication methods
+    .addClientAuthenticationMethod(new ClientSecretBasic())
+    .addClientAuthenticationMethod(new ClientSecretPost())
+    .addClientAuthenticationMethod(new NoneAuthMethod())
+    .setTokenType(new BearerToken())
+    // Define scopes
+    .setScopes({
+        profile: 'Access to basic profile information such as name and picture.',
+        email: "Access to the user's email address and its verification status.",
+        read: 'Grants read-only access to protected resources',
+        write: 'Grants write access to protected resources',
+    })
+
+    // Authorization
+    .authorizationRoute<object, { Payload: { username?: string; password?: string } }>((route) =>
+        route
+            .setPath('/oauth2/v1.0/authorize')
+            .setUsernameField('username')
+            .setPasswordField('password')
+            .generateCode(async ({ clientId, codeChallenge, scope }, req, _h) => {
+                // client exists?
+                const client = VALID_CLIENTS.find((c) => c.client_id === clientId);
+                if (!client) return null;
+
+                // filter client's allowed scoped
+                const requestedScopes = (scope ?? '').split(/\\s+/).filter(Boolean);
+                const grantedScopes = requestedScopes.length
+                    ? requestedScopes.filter((s) => client.allowed_scopes.includes(s))
+                    : client.allowed_scopes;
+                if (grantedScopes.length === 0) return null;
+
+                // user exists?
+                const user = REGISTERED_USERS.find(
+                    (u) => u.username === req.payload.username && u.password === req.payload.password
+                );
+                if (!user) return null;
+
+                // generate code
+                const code = \`auth-${Date.now()}\`;
+                authCodesStore.set(code, { clientId, scopes: grantedScopes, userId: user.id, codeChallenge });
+                return { type: 'code', value: code };
+            })
+            .finalizeAuthorization(async (ctx, _params, _req, h) => {
+                // redirect to callback url (could do something else depending on the code result)
+                const matcher = createMatchAuthCodeResult({
+                    code: async () => h.redirect(ctx.fullRedirectUri),
+                    continue: async () => h.redirect(ctx.fullRedirectUri),
+                    deny: async () => h.redirect(ctx.fullRedirectUri),
+                });
+                return matcher(ctx.authorizationResult);
+            })
+    )
+
+    // Token exchange
+    .tokenRoute((route) =>
+        route.generateToken(
+            async ({
+                clientId,
+                ttl,
+                tokenType,
+                code,
+                clientSecret,
+                codeVerifier,
+                createJwtAccessToken,
+                createIdToken,
+                verifyCodeVerifier,
+            }) => {
+                const entry = authCodesStore.get(code);
+                if (!entry || entry.clientId !== clientId) return null;
+
+                const client = VALID_CLIENTS.find((c) => c.client_id === clientId);
+                if (!client) {
+                    return {
+                        error: OAuth2ErrorCode.INVALID_CLIENT,
+                        error_description: 'Client authentication failed.',
+                    };
+                }
+
+                if (entry.codeChallenge && codeVerifier) {
+                    if (!verifyCodeVerifier(codeVerifier, entry.codeChallenge)) {
+                        return {
+                            error: OAuth2ErrorCode.INVALID_GRANT,
+                            error_description: 'Invalid authorization grant.',
+                        };
+                    }
+                } else if (clientSecret) {
+                    if (client.client_secret !== clientSecret) {
+                        return {
+                            error: OAuth2ErrorCode.INVALID_CLIENT,
+                            error_description: 'Client authentication failed.',
+                        };
+                    }
+                } else {
+                    return {
+                        error: OAuth2ErrorCode.INVALID_REQUEST,
+                        error_description: 'Missing or invalid request parameter.',
+                    };
+                }
+
+                const user = REGISTERED_USERS.find((u) => u.id === entry.userId);
+                if (!user) {
+                    return {
+                        error: OAuth2ErrorCode.INVALID_GRANT,
+                        error_description: 'Invalid authorization grant.',
+                    };
+                }
+
+                // Generate a signed JWT access token
+                const { token: accessToken } = await createJwtAccessToken!({
+                    sub: entry.userId,
+                    client_id: clientId,
+                    scope: entry.scopes,
+                });
+
+                // Generate a signed JWT id token
+                const idToken = entry.scopes.includes('openid')
+                    ? (await createIdToken!({ sub: entry.userId, name: user.username, aud: clientId })).token
+                    : undefined;
+
+                // Return token response
+                return new OAuth2TokenResponse({ access_token: accessToken })
+                    .setExpiresIn(ttl)
+                    .setTokenType(tokenType)
+                    .setScope(entry.scopes)
+                    .setIdToken(idToken);
+            }
+        )
+    )
+
+    // Access Token Validation
+    .validate(async (_req, { jwtAccessTokenPayload }) => {
+        if (!jwtAccessTokenPayload?.sub) return { isValid: false };
+        return {
+            isValid: true,
+            credentials: {
+                user: {
+                    id: jwtAccessTokenPayload.sub,
+                    clientId: jwtAccessTokenPayload.client_id,
+                },
+                scope: Array.isArray(jwtAccessTokenPayload.scope) ? jwtAccessTokenPayload.scope : [],
+            },
+        };
+    })
+        
+    // JWKS
+    .jwksRoute((route) => route.setPath('/discovery/v1.0/keys')) // activates jwks uri
+    .setPublicKeyExpiry(86400) // 24h
+    .setJwksKeyStore(createInMemoryKeyStore()) // store for JWKS
+    .setJwksRotatorOptions({
+        intervalMs: 7.884e9, // 91 days
+        timestampStore: createInMemoryKeyStore(),
+    });
+`;
+};
+//# sourceMappingURL=oauth2-flow-generator.js.map

package/lib/generators/oauth2-flow-generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth2-flow-generator.js","sourceRoot":"","sources":["../../src/generators/oauth2-flow-generator.ts"],"names":[],"mappings":"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"}

package/lib/generators/oauth2-util-generator.d.ts

@@ -0,0 +1,14 @@
+import { FileGenerator, FileGeneratorType, Question } from '@kaapi/cli/definitions';
+export declare class OAuth2UtilGenerator implements FileGenerator {
+    #private;
+    get type(): FileGeneratorType;
+    get name(): 'oauth2-util';
+    get description(): string;
+    get notes(): string[];
+    get options(): Record<string, string>;
+    init(options: Record<string, unknown>): void;
+    isValid(): boolean;
+    getFileContent(): string;
+    getQuestions(): Question[];
+    getFilename(): string;
+}