@depup/graphql-codegen__cli 6.2.1-depup.0

package/typings/config.d.ts

@@ -0,0 +1,152 @@
+import { Profiler, Types } from '@graphql-codegen/plugin-helpers';
+import { GraphQLSchema } from 'graphql';
+import { GraphQLConfig } from 'graphql-config';
+export type CodegenConfig = Types.Config;
+export type YamlCliFlags = {
+    config: string;
+    watch: boolean | string | string[];
+    require: string[];
+    overwrite: boolean;
+    project: string;
+    silent: boolean;
+    errorsOnly: boolean;
+    profile: boolean;
+    check?: boolean;
+    verbose?: boolean;
+    debug?: boolean;
+    ignoreNoDocuments?: boolean;
+    emitLegacyCommonJSImports?: boolean;
+    importExtension?: '' | `.${string}`;
+};
+export declare function generateSearchPlaces(moduleName: string): string[];
+export type CodegenConfigLoader = (filepath: string, content: string) => Promise<Types.Config> | Types.Config;
+export interface LoadCodegenConfigOptions {
+    /**
+     * The path to the config file or directory contains the config file.
+     * @default process.cwd()
+     */
+    configFilePath?: string;
+    /**
+     * The name of the config file
+     * @default codegen
+     */
+    moduleName?: string;
+    /**
+     * Additional search paths for the config file you want to check
+     */
+    searchPlaces?: string[];
+    /**
+     * @default codegen
+     */
+    packageProp?: string;
+    /**
+     * Overrides or extends the loaders for specific file extensions
+     */
+    loaders?: Record<string, CodegenConfigLoader>;
+}
+export interface LoadCodegenConfigResult {
+    filepath: string;
+    config: Types.Config;
+    isEmpty?: boolean;
+}
+export declare function loadCodegenConfig({ configFilePath, moduleName, searchPlaces: additionalSearchPlaces, packageProp, loaders: customLoaders, }: LoadCodegenConfigOptions): Promise<LoadCodegenConfigResult>;
+export declare function loadContext(configFilePath?: string): Promise<CodegenContext> | never;
+export declare function buildOptions(): {
+    c: {
+        alias: string;
+        type: "string";
+        describe: string;
+    };
+    w: {
+        alias: string;
+        describe: string;
+        coerce(watch: any): string | boolean | any[];
+    };
+    r: {
+        alias: string;
+        describe: string;
+        type: "array";
+        default: any[];
+    };
+    o: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+    s: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+    e: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+    };
+    profile: {
+        describe: string;
+        type: "boolean";
+    };
+    p: {
+        alias: string;
+        describe: string;
+        type: "string";
+    };
+    v: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+        default: boolean;
+    };
+    d: {
+        alias: string;
+        describe: string;
+        type: "boolean";
+        default: boolean;
+    };
+    'emit-legacy-common-js-imports': {
+        describe: string;
+        type: "boolean";
+    };
+    'import-extension': {
+        describe: string;
+        type: "string";
+    };
+    'ignore-no-documents': {
+        describe: string;
+        type: "boolean";
+    };
+};
+export declare function parseArgv(argv?: string[]): YamlCliFlags;
+export declare function createContext(cliFlags?: YamlCliFlags): Promise<CodegenContext>;
+export declare function updateContextWithCliFlags(context: CodegenContext, cliFlags: YamlCliFlags): void;
+export declare class CodegenContext {
+    private _config;
+    private _graphqlConfig?;
+    private config;
+    private _project?;
+    private _checkMode;
+    private _pluginContext;
+    cwd: string;
+    filepath: string;
+    profiler: Profiler;
+    profilerOutput?: string;
+    checkModeStaleFiles: any[];
+    constructor({ config, graphqlConfig, filepath, }: {
+        config?: Types.Config;
+        graphqlConfig?: GraphQLConfig;
+        filepath?: string;
+    });
+    useProject(name?: string): void;
+    getConfig<T>(extraConfig?: T): T & Types.Config;
+    updateConfig(config: Partial<Types.Config>): void;
+    enableCheckMode(): void;
+    get checkMode(): boolean;
+    useProfiler(): void;
+    getPluginContext(): {
+        [key: string]: any;
+    };
+    loadSchema(pointer: Types.Schema | Types.Schema[]): Promise<GraphQLSchema>;
+    loadDocuments(pointer: Types.OperationDocument[]): Promise<Types.DocumentFile[]>;
+}
+export declare function ensureContext(input: CodegenContext | Types.Config): CodegenContext;

package/typings/documentTransforms.d.cts

@@ -0,0 +1,3 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+export declare function getDocumentTransform(documentTransform: Types.OutputDocumentTransform, loader: Types.PackageLoaderFn<Types.DocumentTransformObject>, defaultName: string): Promise<Types.ConfiguredDocumentTransform>;
+export declare function getDocumentTransformByName(name: string, loader: Types.PackageLoaderFn<Types.DocumentTransformObject>): Promise<Types.DocumentTransformObject>;

package/typings/documentTransforms.d.ts

@@ -0,0 +1,3 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+export declare function getDocumentTransform(documentTransform: Types.OutputDocumentTransform, loader: Types.PackageLoaderFn<Types.DocumentTransformObject>, defaultName: string): Promise<Types.ConfiguredDocumentTransform>;
+export declare function getDocumentTransformByName(name: string, loader: Types.PackageLoaderFn<Types.DocumentTransformObject>): Promise<Types.DocumentTransformObject>;

package/typings/generate-and-save.d.cts

@@ -0,0 +1,10 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { CodegenContext } from './config.cjs';
+export declare function generate(input: CodegenContext | (Types.Config & {
+    cwd?: string;
+}), saveToFile?: boolean): Promise<Types.FileOutput[]
+/**
+ * When this function runs in watch mode, it'd return an empty promise that doesn't resolve until the watcher exits
+ * FIXME: this effectively makes the result `any`, which loses type-hints
+ */
+ | any>;

package/typings/generate-and-save.d.ts

@@ -0,0 +1,10 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { CodegenContext } from './config.js';
+export declare function generate(input: CodegenContext | (Types.Config & {
+    cwd?: string;
+}), saveToFile?: boolean): Promise<Types.FileOutput[]
+/**
+ * When this function runs in watch mode, it'd return an empty promise that doesn't resolve until the watcher exits
+ * FIXME: this effectively makes the result `any`, which loses type-hints
+ */
+ | any>;

package/typings/graphql-config.d.cts

@@ -0,0 +1,3 @@
+import { GraphQLConfig, GraphQLExtensionDeclaration } from 'graphql-config';
+export declare const CodegenExtension: GraphQLExtensionDeclaration;
+export declare function findAndLoadGraphQLConfig(filepath?: string): Promise<GraphQLConfig | void>;

package/typings/graphql-config.d.ts

@@ -0,0 +1,3 @@
+import { GraphQLConfig, GraphQLExtensionDeclaration } from 'graphql-config';
+export declare const CodegenExtension: GraphQLExtensionDeclaration;
+export declare function findAndLoadGraphQLConfig(filepath?: string): Promise<GraphQLConfig | void>;

package/typings/hooks.d.cts

@@ -0,0 +1,11 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+export declare const lifecycleHooks: (_hooks?: Partial<Types.LifecycleHooksDefinition>) => {
+    afterStart: () => Promise<void>;
+    onWatchTriggered: (event: string, path: string) => Promise<void>;
+    onError: (error: string) => Promise<void>;
+    afterOneFileWrite: (path: string) => Promise<void>;
+    afterAllFileWrite: (paths: string[]) => Promise<void>;
+    beforeOneFileWrite: (path: string, content: string) => Promise<string>;
+    beforeAllFileWrite: (paths: string[]) => Promise<void>;
+    beforeDone: () => Promise<void>;
+};

package/typings/hooks.d.ts

@@ -0,0 +1,11 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+export declare const lifecycleHooks: (_hooks?: Partial<Types.LifecycleHooksDefinition>) => {
+    afterStart: () => Promise<void>;
+    onWatchTriggered: (event: string, path: string) => Promise<void>;
+    onError: (error: string) => Promise<void>;
+    afterOneFileWrite: (path: string) => Promise<void>;
+    afterAllFileWrite: (paths: string[]) => Promise<void>;
+    beforeOneFileWrite: (path: string, content: string) => Promise<string>;
+    beforeAllFileWrite: (paths: string[]) => Promise<void>;
+    beforeDone: () => Promise<void>;
+};

package/typings/index.d.cts

@@ -0,0 +1,8 @@
+export * from './cli.cjs';
+export { executeCodegen } from './codegen.cjs';
+export * from './config.cjs';
+export { CodegenConfig } from './config.cjs';
+export { generate } from './generate-and-save.cjs';
+export * from './graphql-config.cjs';
+export * from './init/index.cjs';
+export * from './utils/cli-error.cjs';

package/typings/index.d.ts

@@ -0,0 +1,8 @@
+export * from './cli.js';
+export { executeCodegen } from './codegen.js';
+export * from './config.js';
+export { CodegenConfig } from './config.js';
+export { generate } from './generate-and-save.js';
+export * from './graphql-config.js';
+export * from './init/index.js';
+export * from './utils/cli-error.js';

package/typings/init/helpers.d.cts

@@ -0,0 +1,10 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { Answers } from './types.cjs';
+export declare function writeConfig(answers: Answers, config: Types.Config): Promise<{
+    relativePath: string;
+    fullPath: string;
+}>;
+export declare function writePackage(answers: Answers, configLocation: string): Promise<void>;
+export declare function bold(str: string): string;
+export declare function grey(str: string): string;
+export declare function italic(str: string): string;

package/typings/init/helpers.d.ts

@@ -0,0 +1,10 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { Answers } from './types.js';
+export declare function writeConfig(answers: Answers, config: Types.Config): Promise<{
+    relativePath: string;
+    fullPath: string;
+}>;
+export declare function writePackage(answers: Answers, configLocation: string): Promise<void>;
+export declare function bold(str: string): string;
+export declare function grey(str: string): string;
+export declare function italic(str: string): string;

package/typings/init/index.d.cts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/typings/init/index.d.ts

@@ -0,0 +1 @@
+export declare function init(): Promise<void>;

package/typings/init/plugins.d.cts

@@ -0,0 +1,2 @@
+import { PluginOption } from './types.cjs';
+export declare const plugins: Array<PluginOption>;

package/typings/init/plugins.d.ts

@@ -0,0 +1,2 @@
+import { PluginOption } from './types.js';
+export declare const plugins: Array<PluginOption>;

package/typings/init/questions.d.cts

@@ -0,0 +1,13 @@
+import { type Answers, type PluginOption, Tags } from './types.cjs';
+export declare function getAnswers(possibleTargets: Record<Tags, boolean>): Promise<Answers>;
+export declare function getApplicationTypeChoices(possibleTargets: Record<Tags, boolean>): {
+    name: string;
+    key: string;
+    value: Tags[];
+    checked: boolean;
+}[];
+export declare function getPluginChoices(targets: Tags[]): {
+    name: string;
+    value: PluginOption;
+    checked: boolean;
+}[];

package/typings/init/questions.d.ts

@@ -0,0 +1,13 @@
+import { type Answers, type PluginOption, Tags } from './types.js';
+export declare function getAnswers(possibleTargets: Record<Tags, boolean>): Promise<Answers>;
+export declare function getApplicationTypeChoices(possibleTargets: Record<Tags, boolean>): {
+    name: string;
+    key: string;
+    value: Tags[];
+    checked: boolean;
+}[];
+export declare function getPluginChoices(targets: Tags[]): {
+    name: string;
+    value: PluginOption;
+    checked: boolean;
+}[];

package/typings/init/targets.d.cts

@@ -0,0 +1,2 @@
+import { Tags } from './types.cjs';
+export declare function guessTargets(): Promise<Record<Tags, boolean>>;

package/typings/init/targets.d.ts

@@ -0,0 +1,2 @@
+import { Tags } from './types.js';
+export declare function guessTargets(): Promise<Record<Tags, boolean>>;

package/typings/init/types.d.cts

@@ -0,0 +1,30 @@
+export interface PluginOption {
+    name: string;
+    package: string;
+    value: string;
+    pathInRepo: string;
+    available(tags: Tags[]): boolean;
+    shouldBeSelected(tags: Tags[]): boolean;
+    defaultExtension: string;
+}
+export interface Answers {
+    targets: Tags[];
+    config: string;
+    plugins?: PluginOption[];
+    schema: string;
+    documents?: string;
+    output: string;
+    script: string;
+    introspection: boolean;
+}
+export declare enum Tags {
+    client = "Browser",
+    node = "Node",
+    typescript = "TypeScript",
+    flow = "Flow",
+    angular = "Angular",
+    stencil = "Stencil",
+    react = "React",
+    vue = "Vue",
+    graphqlRequest = "graphqlRequest"
+}

package/typings/init/types.d.ts

@@ -0,0 +1,30 @@
+export interface PluginOption {
+    name: string;
+    package: string;
+    value: string;
+    pathInRepo: string;
+    available(tags: Tags[]): boolean;
+    shouldBeSelected(tags: Tags[]): boolean;
+    defaultExtension: string;
+}
+export interface Answers {
+    targets: Tags[];
+    config: string;
+    plugins?: PluginOption[];
+    schema: string;
+    documents?: string;
+    output: string;
+    script: string;
+    introspection: boolean;
+}
+export declare enum Tags {
+    client = "Browser",
+    node = "Node",
+    typescript = "TypeScript",
+    flow = "Flow",
+    angular = "Angular",
+    stencil = "Stencil",
+    react = "React",
+    vue = "Vue",
+    graphqlRequest = "graphqlRequest"
+}

package/typings/load.d.cts

@@ -0,0 +1,15 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { UnnormalizedTypeDefPointer } from '@graphql-tools/load';
+import { GraphQLSchema } from 'graphql';
+export declare const defaultSchemaLoadOptions: {
+    assumeValidSDL: boolean;
+    sort: boolean;
+    convertExtensions: boolean;
+    includeSources: boolean;
+};
+export declare const defaultDocumentsLoadOptions: {
+    sort: boolean;
+    skipGraphQLImport: boolean;
+};
+export declare function loadSchema(schemaPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[], config: Types.Config): Promise<GraphQLSchema>;
+export declare function loadDocuments(documentPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[], config: Types.Config): Promise<Types.DocumentFile[]>;

package/typings/load.d.ts

@@ -0,0 +1,15 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { UnnormalizedTypeDefPointer } from '@graphql-tools/load';
+import { GraphQLSchema } from 'graphql';
+export declare const defaultSchemaLoadOptions: {
+    assumeValidSDL: boolean;
+    sort: boolean;
+    convertExtensions: boolean;
+    includeSources: boolean;
+};
+export declare const defaultDocumentsLoadOptions: {
+    sort: boolean;
+    skipGraphQLImport: boolean;
+};
+export declare function loadSchema(schemaPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[], config: Types.Config): Promise<GraphQLSchema>;
+export declare function loadDocuments(documentPointers: UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[], config: Types.Config): Promise<Types.DocumentFile[]>;

package/typings/plugins.d.cts

@@ -0,0 +1,2 @@
+import { CodegenPlugin, Types } from '@graphql-codegen/plugin-helpers';
+export declare function getPluginByName(name: string, pluginLoader: Types.PackageLoaderFn<CodegenPlugin>): Promise<CodegenPlugin>;

package/typings/plugins.d.ts

@@ -0,0 +1,2 @@
+import { CodegenPlugin, Types } from '@graphql-codegen/plugin-helpers';
+export declare function getPluginByName(name: string, pluginLoader: Types.PackageLoaderFn<CodegenPlugin>): Promise<CodegenPlugin>;

package/typings/presets.d.cts

@@ -0,0 +1,5 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+export declare function getPresetByName(name: string, loader: Types.PackageLoaderFn<{
+    preset?: Types.OutputPreset;
+    default?: Types.OutputPreset;
+}>): Promise<Types.OutputPreset>;

package/typings/presets.d.ts

@@ -0,0 +1,5 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+export declare function getPresetByName(name: string, loader: Types.PackageLoaderFn<{
+    preset?: Types.OutputPreset;
+    default?: Types.OutputPreset;
+}>): Promise<Types.OutputPreset>;

package/typings/utils/abort-controller-polyfill.d.cts

@@ -0,0 +1,5 @@
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+export { AbortController };

package/typings/utils/abort-controller-polyfill.d.ts

@@ -0,0 +1,5 @@
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+export { AbortController };

package/typings/utils/cli-error.d.cts

@@ -0,0 +1,10 @@
+type CompositeError = Error;
+type ListrError = Error & {
+    errors: CompositeError[];
+};
+export declare function isListrError(err: Error & {
+    name?: unknown;
+    errors?: unknown;
+}): err is ListrError;
+export declare function cliError(err: any, exitOnError?: boolean): void;
+export {};

package/typings/utils/cli-error.d.ts

@@ -0,0 +1,10 @@
+type CompositeError = Error;
+type ListrError = Error & {
+    errors: CompositeError[];
+};
+export declare function isListrError(err: Error & {
+    name?: unknown;
+    errors?: unknown;
+}): err is ListrError;
+export declare function cliError(err: any, exitOnError?: boolean): void;
+export {};

package/typings/utils/debugging.d.cts

@@ -0,0 +1,3 @@
+export declare function debugLog(message: string, ...meta: any[]): void;
+export declare function printLogs(): void;
+export declare function resetLogs(): void;

package/typings/utils/debugging.d.ts

@@ -0,0 +1,3 @@
+export declare function debugLog(message: string, ...meta: any[]): void;
+export declare function printLogs(): void;
+export declare function resetLogs(): void;

package/typings/utils/file-system.d.cts

@@ -0,0 +1,8 @@
+import { promises } from 'fs';
+declare const fsAccess: typeof promises.access;
+export declare function access(...args: Parameters<typeof fsAccess>): Promise<void>;
+export declare function writeFile(filepath: string, content: string): Promise<void>;
+export declare function readFile(filepath: string): Promise<string>;
+export declare function unlinkFile(filePath: string, cb?: (err?: Error) => any): void;
+export declare function mkdirp(filePath: string): Promise<string>;
+export {};

package/typings/utils/file-system.d.ts

@@ -0,0 +1,8 @@
+import { promises } from 'fs';
+declare const fsAccess: typeof promises.access;
+export declare function access(...args: Parameters<typeof fsAccess>): Promise<void>;
+export declare function writeFile(filepath: string, content: string): Promise<void>;
+export declare function readFile(filepath: string): Promise<string>;
+export declare function unlinkFile(filePath: string, cb?: (err?: Error) => any): void;
+export declare function mkdirp(filePath: string): Promise<string>;
+export {};

package/typings/utils/get-latest-version.d.cts

@@ -0,0 +1,6 @@
+/**
+ * Fetches the version directly from the registry instead of depending on
+ * an ESM only module as latest-version does.
+ * @param packageName
+ */
+export declare function getLatestVersion(packageName: string): Promise<string>;

package/typings/utils/get-latest-version.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Fetches the version directly from the registry instead of depending on
+ * an ESM only module as latest-version does.
+ * @param packageName
+ */
+export declare function getLatestVersion(packageName: string): Promise<string>;

package/typings/utils/helpers.d.cts

@@ -0,0 +1 @@
+export declare function isURL(str: string): boolean;

package/typings/utils/helpers.d.ts

@@ -0,0 +1 @@
+export declare function isURL(str: string): boolean;

package/typings/utils/logger.d.cts

@@ -0,0 +1,5 @@
+import { Logger } from 'ts-log';
+export declare function getLogger(): Logger;
+export declare function setLogger(newLogger: Logger): void;
+export declare function setSilentLogger(): void;
+export declare function useWinstonLogger(): void;

package/typings/utils/logger.d.ts

@@ -0,0 +1,5 @@
+import { Logger } from 'ts-log';
+export declare function getLogger(): Logger;
+export declare function setLogger(newLogger: Logger): void;
+export declare function setSilentLogger(): void;
+export declare function useWinstonLogger(): void;

package/typings/utils/patterns.d.cts

@@ -0,0 +1,91 @@
+import { Types } from '@graphql-codegen/plugin-helpers';
+import { CodegenContext } from '../config.cjs';
+type NegatedPattern = `!${string}`;
+/**
+ * Flatten a list of pattern sets to be a list of only the affirmative patterns
+ * are contained in all of them.
+ *
+ * This can be used, for example, to find the "longest common prefix directory"
+ * by examining `mm.scan(pattern).base` for each `pattern`.
+ */
+export declare const allAffirmativePatternsFromPatternSets: (patternSets: PatternSet[]) => string[];
+/**
+ * Create a rebuild trigger that follows the algorithm described here:
+ * https://github.com/dotansimha/graphql-code-generator/issues/9270#issuecomment-1496765045
+ *
+ * There is a flow chart diagram in that comment.
+ *
+ * Basically:
+ *
+ *  * "Global" patterns are defined at top level of config file, and "local"
+ *    patterns are defined for each output target
+ *  * Each pattern can have "watch", "documents", and "schemas"
+ *  * Watch patterns (global and local) always take precedence over documents and
+ *    schemas patterns, i.e. a watch negation always negates, and a watch match is
+ *    a match even if it would be negated by some pattern in documents or schemas
+ *  * The trigger returns true if any output target's local patterns result in
+ *    a match, after considering the precedence of any global and local negations
+ */
+export declare const makeShouldRebuild: ({ globalPatternSet, localPatternSets, }: {
+    globalPatternSet: PatternSet;
+    localPatternSets: PatternSet[];
+}) => ({ path: absolutePath }: {
+    path: string;
+}) => boolean;
+/**
+ * Create the pattern set for the "global" (top level) config.
+ *
+ * In the `shouldRebuild` algorithm, any of these watch patterns will take
+ * precedence over local configs, and any schemas and documents patterns will be
+ * mixed into the pattern set of each local config.
+ */
+export declare const makeGlobalPatternSet: (initialContext: CodegenContext) => {
+    watch: SortedPatterns<string>;
+    schemas: SortedPatterns<string>;
+    documents: SortedPatterns<string>;
+};
+/**
+ * Create the pattern set for a "local" (output target) config
+ *
+ * In the `shouldRebuild` algorithm, any of these watch patterns will take
+ * precedence over documents or schemas patterns, and the documents and schemas
+ * patterns will be mixed into the pattern set of their respective gobal pattern
+ * set equivalents.
+ */
+export declare const makeLocalPatternSet: (conf: Types.ConfiguredOutput) => {
+    watch: SortedPatterns<string>;
+    documents: SortedPatterns<string>;
+    schemas: SortedPatterns<string>;
+};
+/**
+ * Given a list of micromatch patterns, sort them into `patterns` (all of them),
+ * `affirmative` (only the affirmative patterns), and `negated` (only the negated patterns)
+ *
+ * @param patterns List of micromatch patterns
+ */
+export declare const sortPatterns: <P extends string | NegatedPattern>(patterns: P[]) => SortedPatterns<P>;
+/**
+ * A type that "sorts" (or "groups") patterns. For a given list of `patterns`,
+ * this type will include the original list in `patterns`, all of its
+ * "affirmative" (non-negated) patterns in `affirmative`, and all of its
+ * "negated" patterns in `negated`
+ */
+type SortedPatterns<PP extends string | NegatedPattern = string | NegatedPattern> = {
+    /** List of patterns, which could include both negated and affirmative patterns */
+    patterns: PP[];
+    /** List of only the affirmative (non-negated) patterns in `patterns` */
+    affirmative: PP[];
+    /** List of only the negated patterns in `patterns` */
+    negated: Extract<PP, NegatedPattern>[];
+};
+/**
+ * The global (top-level) config and each local (output target) config can have
+ * patterns which are separable into "watch" (always takes precedence), "documents",
+ * and "schemas". This type can hold sorted versions of these patterns.
+ */
+type PatternSet = {
+    watch: SortedPatterns;
+    documents: SortedPatterns;
+    schemas: SortedPatterns;
+};
+export {};