aws-cdk 0.0.0

package/lib/logging.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.highlight = exports.success = exports.trace = exports.debug = exports.result = exports.info = exports.warning = exports.error = void 0;
+const util = require("util");
+const chalk = require("chalk");
+const cli_io_host_1 = require("./toolkit/cli-io-host");
+/**
+ * Internal helper that processes log inputs into a consistent format.
+ * Handles string interpolation, format strings, and object parameter styles.
+ * Applies optional styling and sends the message to the IoHost.
+ */
+function formatMessageAndLog(level, input, style, ...args) {
+    // Extract message and code from input, using new default code format
+    const { message, code = getDefaultCode(level) } = typeof input === 'object' ? input : { message: input };
+    // Format message if args are provided
+    const formattedMessage = args.length > 0
+        ? util.format(message, ...args)
+        : message;
+    // Apply style if provided
+    const finalMessage = style ? style(formattedMessage) : formattedMessage;
+    const ioHost = cli_io_host_1.CliIoHost.instance();
+    const ioMessage = {
+        time: new Date(),
+        action: ioHost.currentAction,
+        level,
+        message: finalMessage,
+        code,
+    };
+    void ioHost.notify(ioMessage);
+}
+function getDefaultCode(level, category = 'TOOLKIT') {
+    const levelIndicator = level === 'error' ? 'E' :
+        level === 'warn' ? 'W' :
+            'I';
+    return `CDK_${category}_${levelIndicator}0000`;
+}
+// Exported logging functions. If any additional logging functionality is required, it should be added as
+// a new logging function here.
+/**
+ * Logs an error level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * error(`operation failed: ${e}`) // infers default error code `CDK_TOOLKIT_E000`
+ * error('operation failed: %s', e) // infers default error code `CDK_TOOLKIT_E000`
+ * error({ message: 'operation failed', code: 'CDK_SDK_E001' }) // specifies error code `CDK_SDK_E001`
+ * error({ message: 'operation failed: %s', code: 'CDK_SDK_E001' }, e) // specifies error code `CDK_SDK_E001`
+ * ```
+ */
+const error = (input, ...args) => {
+    return formatMessageAndLog('error', input, undefined, ...args);
+};
+exports.error = error;
+/**
+ * Logs an warning level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * warning(`deprected feature: ${message}`) // infers default warning code `CDK_TOOLKIT_W000`
+ * warning('deprected feature: %s', message) // infers default warning code `CDK_TOOLKIT_W000`
+ * warning({ message: 'deprected feature', code: 'CDK_SDK_W001' }) // specifies warning code `CDK_SDK_W001`
+ * warning({ message: 'deprected feature: %s', code: 'CDK_SDK_W001' }, message) // specifies warning code `CDK_SDK_W001`
+ * ```
+ */
+const warning = (input, ...args) => {
+    return formatMessageAndLog('warn', input, undefined, ...args);
+};
+exports.warning = warning;
+/**
+ * Logs an info level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * info(`processing: ${message}`) // infers default info code `CDK_TOOLKIT_I000`
+ * info('processing: %s', message) // infers default info code `CDK_TOOLKIT_I000`
+ * info({ message: 'processing', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * info({ message: 'processing: %s', code: 'CDK_TOOLKIT_I001' }, message) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const info = (input, ...args) => {
+    return formatMessageAndLog('info', input, undefined, ...args);
+};
+exports.info = info;
+/**
+ * Logs an result. In the CLI, this always goes to stdout.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * result(`${JSON.stringify(stats)}`) // infers default info code `CDK_TOOLKIT_I000`
+ * result('{"count": %d}', count) // infers default info code `CDK_TOOLKIT_I000`
+ * result({ message: 'stats: %j', code: 'CDK_DATA_I001' }) // specifies info code `CDK_DATA_I001`
+ * result({ message: 'stats: %j', code: 'CDK_DATA_I001' }, stats) // specifies info code `CDK_DATA_I001`
+ * ```
+ */
+const result = (input, ...args) => {
+    return formatMessageAndLog('result', input, undefined, ...args);
+};
+exports.result = result;
+/**
+ * Logs a debug level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * debug(`state: ${JSON.stringify(state)}`) // infers default info code `CDK_TOOLKIT_I000`
+ * debug('cache hit ratio: %d%%', ratio) // infers default info code `CDK_TOOLKIT_I000`
+ * debug({ message: 'state update', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * debug({ message: 'ratio: %d%%', code: 'CDK_TOOLKIT_I001' }, ratio) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const debug = (input, ...args) => {
+    return formatMessageAndLog('debug', input, undefined, ...args);
+};
+exports.debug = debug;
+/**
+ * Logs a trace level message.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * trace(`entered ${name} with ${args}`) // infers default info code `CDK_TOOLKIT_I000`
+ * trace('method: %s, args: %j', name, args) // infers default info code `CDK_TOOLKIT_I000`
+ * trace({ message: 'entered', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * trace({ message: 'method: %s', code: 'CDK_TOOLKIT_I001' }, name) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const trace = (input, ...args) => {
+    return formatMessageAndLog('trace', input, undefined, ...args);
+};
+exports.trace = trace;
+/**
+ * Logs an info level success message in green text.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * success(`deployment completed: ${name}`) // infers default info code `CDK_TOOLKIT_I000`
+ * success('processed %d items', count) // infers default info code `CDK_TOOLKIT_I000`
+ * success({ message: 'completed', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * success({ message: 'items: %d', code: 'CDK_TOOLKIT_I001' }, count) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const success = (input, ...args) => {
+    return formatMessageAndLog('info', input, chalk.green, ...args);
+};
+exports.success = success;
+/**
+ * Logs an info level message in bold text.
+ *
+ * Can be used in multiple ways:
+ * ```ts
+ * highlight(`important: ${msg}`) // infers default info code `CDK_TOOLKIT_I000`
+ * highlight('attention required: %s', reason) // infers default info code `CDK_TOOLKIT_I000`
+ * highlight({ message: 'notice', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`
+ * highlight({ message: 'notice: %s', code: 'CDK_TOOLKIT_I001' }, msg) // specifies info code `CDK_TOOLKIT_I001`
+ * ```
+ */
+const highlight = (input, ...args) => {
+    return formatMessageAndLog('info', input, chalk.bold, ...args);
+};
+exports.highlight = highlight;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"logging.js","sourceRoot":"","sources":["logging.ts"],"names":[],"mappings":"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","sourcesContent":["import * as util from 'util';\nimport * as chalk from 'chalk';\nimport { IoMessageLevel, IoMessage, CliIoHost, IoMessageSpecificCode, IoMessageCode, IoMessageCodeCategory, IoCodeLevel } from './toolkit/cli-io-host';\n\n/**\n * Internal helper that processes log inputs into a consistent format.\n * Handles string interpolation, format strings, and object parameter styles.\n * Applies optional styling and sends the message to the IoHost.\n */\nfunction formatMessageAndLog(\n  level: IoMessageLevel,\n  input: LogInput<IoCodeLevel>,\n  style?: (str: string) => string,\n  ...args: unknown[]\n): void {\n  // Extract message and code from input, using new default code format\n  const { message, code = getDefaultCode(level) } = typeof input === 'object' ? input : { message: input };\n\n  // Format message if args are provided\n  const formattedMessage = args.length > 0\n    ? util.format(message, ...args)\n    : message;\n\n  // Apply style if provided\n  const finalMessage = style ? style(formattedMessage) : formattedMessage;\n\n  const ioHost = CliIoHost.instance();\n  const ioMessage: IoMessage<undefined> = {\n    time: new Date(),\n    action: ioHost.currentAction,\n    level,\n    message: finalMessage,\n    code,\n  };\n\n  void ioHost.notify(ioMessage);\n}\n\nfunction getDefaultCode(level: IoMessageLevel, category: IoMessageCodeCategory = 'TOOLKIT'): IoMessageCode {\n  const levelIndicator = level === 'error' ? 'E' :\n    level === 'warn' ? 'W' :\n      'I';\n  return `CDK_${category}_${levelIndicator}0000`;\n}\n\n// Type for the object parameter style\ninterface LogParams<L extends IoCodeLevel> {\n  /**\n   * @see {@link IoMessage.code}\n   */\n  readonly code?: IoMessageSpecificCode<L>;\n  /**\n   * @see {@link IoMessage.message}\n   */\n  readonly message: string;\n}\n\n// Type for the exported log function arguments\ntype LogInput<L extends IoCodeLevel> = string | LogParams<L>;\n\n// Exported logging functions. If any additional logging functionality is required, it should be added as\n// a new logging function here.\n\n/**\n * Logs an error level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * error(`operation failed: ${e}`) // infers default error code `CDK_TOOLKIT_E000`\n * error('operation failed: %s', e) // infers default error code `CDK_TOOLKIT_E000`\n * error({ message: 'operation failed', code: 'CDK_SDK_E001' }) // specifies error code `CDK_SDK_E001`\n * error({ message: 'operation failed: %s', code: 'CDK_SDK_E001' }, e) // specifies error code `CDK_SDK_E001`\n * ```\n */\nexport const error = (input: LogInput<'E'>, ...args: unknown[]) => {\n  return formatMessageAndLog('error', input, undefined, ...args);\n};\n\n/**\n * Logs an warning level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * warning(`deprected feature: ${message}`) // infers default warning code `CDK_TOOLKIT_W000`\n * warning('deprected feature: %s', message) // infers default warning code `CDK_TOOLKIT_W000`\n * warning({ message: 'deprected feature', code: 'CDK_SDK_W001' }) // specifies warning code `CDK_SDK_W001`\n * warning({ message: 'deprected feature: %s', code: 'CDK_SDK_W001' }, message) // specifies warning code `CDK_SDK_W001`\n * ```\n */\nexport const warning = (input: LogInput<'W'>, ...args: unknown[]) => {\n  return formatMessageAndLog('warn', input, undefined, ...args);\n};\n\n/**\n * Logs an info level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * info(`processing: ${message}`) // infers default info code `CDK_TOOLKIT_I000`\n * info('processing: %s', message) // infers default info code `CDK_TOOLKIT_I000`\n * info({ message: 'processing', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * info({ message: 'processing: %s', code: 'CDK_TOOLKIT_I001' }, message) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const info = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('info', input, undefined, ...args);\n};\n\n/**\n * Logs an result. In the CLI, this always goes to stdout.\n *\n * Can be used in multiple ways:\n * ```ts\n * result(`${JSON.stringify(stats)}`) // infers default info code `CDK_TOOLKIT_I000`\n * result('{\"count\": %d}', count) // infers default info code `CDK_TOOLKIT_I000`\n * result({ message: 'stats: %j', code: 'CDK_DATA_I001' }) // specifies info code `CDK_DATA_I001`\n * result({ message: 'stats: %j', code: 'CDK_DATA_I001' }, stats) // specifies info code `CDK_DATA_I001`\n * ```\n */\nexport const result = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('result', input, undefined, ...args);\n};\n\n/**\n * Logs a debug level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * debug(`state: ${JSON.stringify(state)}`) // infers default info code `CDK_TOOLKIT_I000`\n * debug('cache hit ratio: %d%%', ratio) // infers default info code `CDK_TOOLKIT_I000`\n * debug({ message: 'state update', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * debug({ message: 'ratio: %d%%', code: 'CDK_TOOLKIT_I001' }, ratio) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const debug = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('debug', input, undefined, ...args);\n};\n\n/**\n * Logs a trace level message.\n *\n * Can be used in multiple ways:\n * ```ts\n * trace(`entered ${name} with ${args}`) // infers default info code `CDK_TOOLKIT_I000`\n * trace('method: %s, args: %j', name, args) // infers default info code `CDK_TOOLKIT_I000`\n * trace({ message: 'entered', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * trace({ message: 'method: %s', code: 'CDK_TOOLKIT_I001' }, name) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const trace = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('trace', input, undefined, ...args);\n};\n\n/**\n * Logs an info level success message in green text.\n *\n * Can be used in multiple ways:\n * ```ts\n * success(`deployment completed: ${name}`) // infers default info code `CDK_TOOLKIT_I000`\n * success('processed %d items', count) // infers default info code `CDK_TOOLKIT_I000`\n * success({ message: 'completed', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * success({ message: 'items: %d', code: 'CDK_TOOLKIT_I001' }, count) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const success = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('info', input, chalk.green, ...args);\n};\n\n/**\n * Logs an info level message in bold text.\n *\n * Can be used in multiple ways:\n * ```ts\n * highlight(`important: ${msg}`) // infers default info code `CDK_TOOLKIT_I000`\n * highlight('attention required: %s', reason) // infers default info code `CDK_TOOLKIT_I000`\n * highlight({ message: 'notice', code: 'CDK_TOOLKIT_I001' }) // specifies info code `CDK_TOOLKIT_I001`\n * highlight({ message: 'notice: %s', code: 'CDK_TOOLKIT_I001' }, msg) // specifies info code `CDK_TOOLKIT_I001`\n * ```\n */\nexport const highlight = (input: LogInput<'I'>, ...args: unknown[]) => {\n  return formatMessageAndLog('info', input, chalk.bold, ...args);\n};\n"]}

package/lib/migrator.d.ts

@@ -0,0 +1,25 @@
+import type * as cxapi from '@aws-cdk/cx-api';
+import { StackCollection } from './api/cxapp/cloud-assembly';
+import { Deployments, ResourcesToImport } from './api/deployments';
+import { DeployOptions } from './cli/cdk-toolkit';
+export interface ResourceMigratorProps {
+    deployments: Deployments;
+}
+type ResourceMigratorOptions = Pick<DeployOptions, 'roleArn' | 'toolkitStackName' | 'deploymentMethod' | 'progress' | 'rollback'>;
+export declare class ResourceMigrator {
+    private readonly props;
+    constructor(props: ResourceMigratorProps);
+    /**
+     * Checks to see if a migrate.json file exists. If it does and the source is either `filepath` or
+     * is in the same environment as the stack deployment, a new stack is created and the resources are
+     * migrated to the stack using an IMPORT changeset. The normal deployment will resume after this is complete
+     * to add back in any outputs and the CDKMetadata.
+     */
+    tryMigrateResources(stacks: StackCollection, options: ResourceMigratorOptions): Promise<void>;
+    /**
+     * Creates a new stack with just the resources to be migrated
+     */
+    private performResourceMigration;
+    tryGetResources(environment: cxapi.Environment): Promise<ResourcesToImport | undefined>;
+}
+export {};

package/lib/migrator.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceMigrator = void 0;
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const string_manipulation_1 = require("./api/util/string-manipulation");
+const import_1 = require("./import");
+const logging_1 = require("./logging");
+class ResourceMigrator {
+    constructor(props) {
+        this.props = props;
+    }
+    /**
+     * Checks to see if a migrate.json file exists. If it does and the source is either `filepath` or
+     * is in the same environment as the stack deployment, a new stack is created and the resources are
+     * migrated to the stack using an IMPORT changeset. The normal deployment will resume after this is complete
+     * to add back in any outputs and the CDKMetadata.
+     */
+    async tryMigrateResources(stacks, options) {
+        const stack = stacks.stackArtifacts[0];
+        const migrateDeployment = new import_1.ResourceImporter(stack, this.props.deployments);
+        const resourcesToImport = await this.tryGetResources(await migrateDeployment.resolveEnvironment());
+        if (resourcesToImport) {
+            (0, logging_1.info)('%s: creating stack for resource migration...', chalk.bold(stack.displayName));
+            (0, logging_1.info)('%s: importing resources into stack...', chalk.bold(stack.displayName));
+            await this.performResourceMigration(migrateDeployment, resourcesToImport, options);
+            fs.rmSync('migrate.json');
+            (0, logging_1.info)('%s: applying CDKMetadata and Outputs to stack (if applicable)...', chalk.bold(stack.displayName));
+        }
+    }
+    /**
+     * Creates a new stack with just the resources to be migrated
+     */
+    async performResourceMigration(migrateDeployment, resourcesToImport, options) {
+        const startDeployTime = new Date().getTime();
+        let elapsedDeployTime = 0;
+        // Initial Deployment
+        await migrateDeployment.importResourcesFromMigrate(resourcesToImport, {
+            roleArn: options.roleArn,
+            toolkitStackName: options.toolkitStackName,
+            deploymentMethod: options.deploymentMethod,
+            usePreviousParameters: true,
+            progress: options.progress,
+            rollback: options.rollback,
+        });
+        elapsedDeployTime = new Date().getTime() - startDeployTime;
+        (0, logging_1.info)('\n✨  Resource migration time: %ss\n', (0, string_manipulation_1.formatTime)(elapsedDeployTime));
+    }
+    async tryGetResources(environment) {
+        try {
+            const migrateFile = fs.readJsonSync('migrate.json', {
+                encoding: 'utf-8',
+            });
+            const sourceEnv = migrateFile.Source.split(':');
+            if (sourceEnv[0] === 'localfile' ||
+                (sourceEnv[4] === environment.account && sourceEnv[3] === environment.region)) {
+                return migrateFile.Resources;
+            }
+        }
+        catch (e) {
+            // Nothing to do
+        }
+        return undefined;
+    }
+}
+exports.ResourceMigrator = ResourceMigrator;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/notices.d.ts

@@ -0,0 +1,156 @@
+import type { Environment } from '@aws-cdk/cx-api';
+import { SdkHttpOptions } from './api';
+import type { Context } from './api/context';
+export interface NoticesProps {
+    /**
+     * CDK context
+     */
+    readonly context: Context;
+    /**
+     * Include notices that have already been acknowledged.
+     *
+     * @default false
+     */
+    readonly includeAcknowledged?: boolean;
+    /**
+     * Global CLI option for output directory for synthesized cloud assembly
+     *
+     * @default 'cdk.out'
+     */
+    readonly output?: string;
+    /**
+     * Global CLI option for whether we show notices
+     *
+     * @default true
+     */
+    readonly shouldDisplay?: boolean;
+    /**
+     * Options for the HTTP request
+     */
+    readonly httpOptions?: SdkHttpOptions;
+}
+export interface NoticesPrintOptions {
+    /**
+     * Whether to append the total number of unacknowledged notices to the display.
+     *
+     * @default false
+     */
+    readonly showTotal?: boolean;
+}
+export interface NoticesRefreshOptions {
+    /**
+     * Whether to force a cache refresh regardless of expiration time.
+     *
+     * @default false
+     */
+    readonly force?: boolean;
+    /**
+     * Data source for fetch notices from.
+     *
+     * @default - WebsiteNoticeDataSource
+     */
+    readonly dataSource?: NoticeDataSource;
+}
+export interface NoticesFilterFilterOptions {
+    readonly data: Notice[];
+    readonly cliVersion: string;
+    readonly outDir: string;
+    readonly bootstrappedEnvironments: BootstrappedEnvironment[];
+}
+export declare class NoticesFilter {
+    static filter(options: NoticesFilterFilterOptions): FilteredNotice[];
+    private static findForCliVersion;
+    private static findForFrameworkVersion;
+    private static findForBootstrapVersion;
+    private static resolveAliases;
+}
+/**
+ * Information about a bootstrapped environment.
+ */
+export interface BootstrappedEnvironment {
+    readonly bootstrapStackVersion: number;
+    readonly environment: Environment;
+}
+/**
+ * Provides access to notices the CLI can display.
+ */
+export declare class Notices {
+    /**
+     * Create an instance. Note that this replaces the singleton.
+     */
+    static create(props: NoticesProps): Notices;
+    /**
+     * Get the singleton instance. May return `undefined` if `create` has not been called.
+     */
+    static get(): Notices | undefined;
+    private static _instance;
+    private readonly context;
+    private readonly output;
+    private readonly shouldDisplay;
+    private readonly acknowledgedIssueNumbers;
+    private readonly includeAcknowlegded;
+    private readonly httpOptions;
+    private data;
+    private readonly bootstrappedEnvironments;
+    private constructor();
+    /**
+     * Add a bootstrap information to filter on. Can have multiple values
+     * in case of multi-environment deployments.
+     */
+    addBootstrappedEnvironment(bootstrapped: BootstrappedEnvironment): void;
+    /**
+     * Refresh the list of notices this instance is aware of.
+     * To make sure this never crashes the CLI process, all failures are caught and
+     * silently logged.
+     *
+     * If context is configured to not display notices, this will no-op.
+     */
+    refresh(options?: NoticesRefreshOptions): Promise<void>;
+    /**
+     * Display the relevant notices (unless context dictates we shouldn't).
+     */
+    display(options?: NoticesPrintOptions): void;
+}
+export interface Component {
+    name: string;
+    version: string;
+}
+export interface Notice {
+    title: string;
+    issueNumber: number;
+    overview: string;
+    components: Component[];
+    schemaVersion: string;
+    severity?: string;
+}
+/**
+ * Notice after passing the filter. A filter can augment a notice with
+ * dynamic values as it has access to the dynamic matching data.
+ */
+export declare class FilteredNotice {
+    readonly notice: Notice;
+    private readonly dynamicValues;
+    constructor(notice: Notice);
+    addDynamicValue(key: string, value: string): void;
+    format(): string;
+    private formatOverview;
+    private resolveDynamicValues;
+}
+export interface NoticeDataSource {
+    fetch(): Promise<Notice[]>;
+}
+export declare class WebsiteNoticeDataSource implements NoticeDataSource {
+    private readonly options;
+    constructor(options?: SdkHttpOptions);
+    fetch(): Promise<Notice[]>;
+}
+export declare class CachedDataSource implements NoticeDataSource {
+    private readonly fileName;
+    private readonly dataSource;
+    private readonly skipCache?;
+    constructor(fileName: string, dataSource: NoticeDataSource, skipCache?: boolean | undefined);
+    fetch(): Promise<Notice[]>;
+    private fetchInner;
+    private load;
+    private save;
+}