@power-plant/core 0.0.5 → 0.0.7

package/dist/config-B6Gr29ZK.d.mts

@@ -0,0 +1,566 @@
+import { DeepPartial, MaybePromise } from "@stryke/types/base";
+import { Storage } from "unstorage";
+import { InferExtractOptions, SchemaConfig, SchemaEnvelopeOf, SchemaSourceConfig } from "@power-plant/schema";
+import { InferLoadOptions, LoadReference } from "@stryke/resolve/types";
+import { EnvPaths } from "@stryke/env/get-env-paths";
+
+//#region src/types/meta.d.ts
+type MetaValue<TSpec, TOptions extends object, TValue = any> = TValue | ((spec: TSpec, options: TOptions) => MaybePromise<TValue>);
+type MetaDeprecated = true | string | {
+  message?: string;
+  since?: string;
+  alternative?: string;
+};
+type MetaLink = string | {
+  href: string;
+  description?: string;
+};
+/**
+ * A metadata primitive value.
+ */
+type MetaDataPrimitive = string | number | boolean | null | undefined;
+/**
+ * A record of metadata primitive values.
+ */
+type MetaDataRecord<TSpec, TOptions extends object> = Record<string, MetaValue<TSpec, TOptions, MetaDataPrimitive | MetaDataPrimitive[]>>;
+/**
+ * A record of metadata values.
+ */
+type MetaData<TSpec, TOptions extends object> = Record<string, MetaValue<TSpec, TOptions, MetaDataPrimitive | MetaDataPrimitive[] | MetaDataRecord<TSpec, TOptions>>>;
+interface BaseMeta<TSpec, TOptions extends object> {
+  /**
+   * Additional data associated with the object.
+   */
+  data?: MetaData<TSpec, TOptions>;
+}
+interface MetaConfig<TSpec, TOptions extends object> extends BaseMeta<TSpec, TOptions> {
+  /**
+   * A name for the object, which can be used to identify or reference the object in documentation, tooling, or other contexts. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   *
+   * @remarks
+   * The `name` property is a string that can be used to give the object a human-readable identifier. It can be used in documentation, error messages, or other contexts where it is helpful to have a name associated with the object. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  name?: string;
+  /**
+   * A version string that indicates the version of the object. This property can be used to track changes or updates to the object over time, allowing consumers of the object to determine which version they are working with. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   *
+   * @remarks
+   * The `version` property is a string that can follow any versioning scheme, such as semantic versioning (e.g., "1.0.0", "2.1.3"), date-based versioning (e.g., "2023-06-15"), or any other format that conveys the version of the object. It is recommended to use a consistent versioning scheme across all objects to facilitate easier tracking and management of object versions.
+   *
+   * @defaultValue "1.0"
+   */
+  version?: string | Date | number;
+  /**
+   * A string that describes the object in some way.
+   */
+  description?: string;
+  /**
+   * A string that provides a human-readable name for the object, which can be used in documentation, tooling, or other contexts to identify or reference the object. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   *
+   * @remarks
+   * The `title` property is a string that can be used to give the object a more user-friendly or descriptive name. It can be used in documentation, error messages, or other contexts where it is helpful to have a display name associated with the object. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  title?: MetaValue<TSpec, TOptions, string>;
+  /**
+   * A string that describes when the object is used.
+   */
+  usage?: MetaValue<TSpec, TOptions, string>;
+  /**
+   * Indicates whether the object is deprecated, and optionally provides additional information about the deprecation, such as a message, the version since which it is deprecated, and an alternative object to use instead.
+   *
+   * @remarks
+   * The `deprecated` property can be a boolean value, where `true` indicates that the object is deprecated and `false` indicates that it is not. It can also be a string that provides a message explaining the deprecation, or an object that includes additional details such as a message, the version since which it is deprecated, and an alternative object to use instead. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  deprecated?: MetaValue<TSpec, TOptions, MetaDeprecated>;
+  /**
+   * An array of tags associated with the object. Tags can be used to categorize or label objects for organizational purposes, making it easier to search, filter, or group related objects together. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   *
+   * @remarks
+   * Each tag in the array should be a string that represents a meaningful label or category for the object. It is recommended to use consistent and descriptive tags across objects to facilitate easier management and discovery of related objects.
+   */
+  tags?: MetaValue<TSpec, TOptions, string[]>;
+  /**
+   * An array of links associated with the object. Each link can be a string representing a URL or an object containing a `href` property and an optional `description` property.
+   */
+  links?: MetaValue<TSpec, TOptions, MetaLink[]>;
+}
+interface Meta<TSpec, TOptions extends object> extends BaseMeta<TSpec, TOptions> {
+  /**
+   * A name for the object, which can be used to identify or reference the object in documentation, tooling, or other contexts. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   *
+   * @remarks
+   * The `name` property is a string that can be used to give the object a human-readable identifier. It can be used in documentation, error messages, or other contexts where it is helpful to have a name associated with the schema. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  name?: MetaValue<TSpec, TOptions, string>;
+  /**
+   * A version string that indicates the version of the object. This property can be used to track changes or updates to the object over time, allowing consumers of the object to determine which version they are working with. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   *
+   * @remarks
+   * The `version` property is a string that can follow any versioning scheme, such as semantic versioning (e.g., "1.0.0", "2.1.3"), date-based versioning (e.g., "2023-06-15"), or any other format that conveys the version of the object. It is recommended to use a consistent versioning scheme across all objects to facilitate easier tracking and management of object versions.
+   *
+   * @defaultValue "1.0"
+   */
+  version?: MetaValue<TSpec, TOptions, string | Date | number>;
+  /**
+   * A string that describes the object in some way.
+   */
+  description?: MetaValue<TSpec, TOptions, string>;
+  /**
+   * A string that provides a human-readable name for the object, which can be used in documentation, tooling, or other contexts to identify or reference the object. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   *
+   * @remarks
+   * The `title` property is a string that can be used to give the object a more user-friendly or descriptive name. It can be used in documentation, error messages, or other contexts where it is helpful to have a display name associated with the object. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  title?: MetaValue<TSpec, TOptions, string>;
+  /**
+   * A string that describes when the object is used.
+   */
+  usage?: MetaValue<TSpec, TOptions, string>;
+  /**
+   * Indicates whether the object is deprecated, and optionally provides additional information about the deprecation, such as a message, the version since which it is deprecated, and an alternative object to use instead.
+   *
+   * @remarks
+   * The `deprecated` property can be a boolean value, where `true` indicates that the object is deprecated and `false` indicates that it is not. It can also be a string that provides a message explaining the deprecation, or an object that includes additional details such as a message, the version since which it is deprecated, and an alternative object to use instead. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  deprecated?: MetaValue<TSpec, TOptions, MetaDeprecated>;
+  /**
+   * An array of tags associated with the object. Tags can be used to categorize or label objects for organizational purposes, making it easier to search, filter, or group related objects together. The presence of this property does not affect the validation behavior of the object itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   *
+   * @remarks
+   * Each tag in the array should be a string that represents a meaningful label or category for the object. It is recommended to use consistent and descriptive tags across objects to facilitate easier management and discovery of related objects.
+   */
+  tags?: MetaValue<TSpec, TOptions, string[]>;
+  /**
+   * An array of links associated with the object. Each link can be a string representing a URL or an object containing a `href` property and an optional `description` property.
+   */
+  links?: MetaValue<TSpec, TOptions, MetaLink[]>;
+}
+type InferExtractedMetaDataRecord<TMetaValue extends MetaDataRecord<any, any>> = { [K in keyof TMetaValue]: TMetaValue[K] extends MetaValue<any, any, infer U> ? U extends MetaDataRecord<any, any> ? InferExtractedMetaDataRecord<U> : U : TMetaValue[K] };
+type InferExtractedMeta<TMeta extends Meta<any, any>> = { [K in keyof TMeta]: TMeta[K] extends MetaValue<any, any, infer U> ? U extends MetaDataRecord<any, any> ? InferExtractedMetaDataRecord<U> : U : TMeta[K] };
+//#endregion
+//#region src/types/schema.d.ts
+type SchemaMetaExample<TSpec> = TSpec | {
+  name?: string;
+  description?: string;
+  value: TSpec;
+};
+interface SchemaMetaConfig<TSpec, TOptions extends object = any> extends MetaConfig<TSpec, TOptions> {
+  /**
+   * Examples of valid data for the schema. This can be a single example or an array of examples.
+   */
+  examples?: SchemaMetaExample<TSpec> | MetaValue<TSpec, TOptions, SchemaMetaExample<TSpec>[]>;
+  /**
+   * A description of the specification that is described by this schema.
+   */
+  spec?: MetaValue<TSpec, TOptions, string>;
+}
+interface SchemaMeta<TSpec, TOptions extends object = any> extends Meta<TSpec, TOptions> {
+  /**
+   * Examples of valid data for the schema.
+   */
+  examples: MetaValue<TSpec, TOptions, SchemaMetaExample<TSpec>[]>;
+}
+/**
+ * Schema input wrapper that attaches optional contextual metadata.
+ */
+interface SchemaConfigObject<TSpec, TOptions extends object = any> {
+  /**
+   * The schema that defines the structure of the specification input for the generator. This schema is used to validate the input specification and ensure that it conforms to the expected format before being processed by the generator.
+   */
+  schema: SchemaSourceConfig<TSpec> | SchemaEnvelopeOf<TSpec>;
+  /**
+   * Optional metadata that provides contextual information for the schema.
+   */
+  meta?: SchemaMetaConfig<TSpec, TOptions>;
+}
+type InferCreateSchemaOptions<T extends SchemaSourceConfig<any> | SchemaEnvelopeOf<any> | SchemaConfigObject<any, any>> = T extends SchemaSourceConfig<any> | SchemaEnvelopeOf<any> ? InferExtractOptions<T> : {};
+/**
+ * A schema extracted from a source input, normalized to JSON Schema.
+ */
+interface Schema<TSpec, TOptions extends object = any> extends SchemaEnvelopeOf<TSpec> {
+  /**
+   * Optional contextual metadata associated with the schema.
+   */
+  meta: SchemaMeta<TSpec, TOptions>;
+}
+/**
+ * A normalized JSON Schema extracted from a source input of type `T`. This type represents the result of the schema extraction process, where a raw schema input (which could be in various formats such as Zod, Untyped, Valibot, or as a type definition in TypeScript source code) is transformed into a standardized JSON Schema format. The `SchemaOf<T>` type captures the normalized JSON Schema along with metadata about the source variant and a content hash for caching or identification purposes.
+ *
+ * @template TSpec - The original TypeScript type for which the schema is being extracted. This type parameter is used to derive the appropriate JSON Schema representation based on the structure and constraints of `T`.
+ *
+ * @see {@link Schema}
+ */
+type SchemaOf<TSpec, TOptions extends object = any> = Schema<TSpec, TOptions>;
+//#endregion
+//#region src/types/input.d.ts
+type InputFunction<TSpec, TOptions extends object> = (options: TOptions) => MaybePromise<TSpec>;
+interface InputMetaConfig<TSpec, TOptions extends object> extends MetaConfig<TSpec, TOptions> {
+  /**
+   * A string that describes how the specification will be read/extracted. This property can provide context about the input of the specification, such as whether it is derived from a file, a database, an API, or any other input. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  readFrom?: MetaValue<TSpec, TOptions, string>;
+}
+interface InputMeta<TSpec, TOptions extends object> extends Meta<TSpec, TOptions> {
+  /**
+   * A string that describes how the specification will be read/extracted. This property can provide context about the input of the specification, such as whether it is derived from a file, a database, an API, or any other input. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  readFrom?: string;
+}
+interface InputConfigObject<TSpec, TOptions extends object> {
+  /**
+   * The schema that defines the structure of the specification input for the generator. This schema is used to validate the input specification and ensure that it conforms to the expected format before being processed by the generator.
+   */
+  schema?: SchemaConfig<TSpec> | SchemaConfigObject<TSpec, TOptions>;
+  /**
+   * The input implementation, either as a callable function, a static value, or a file reference.
+   */
+  input: TSpec | InputFunction<TSpec, TOptions> | LoadReference;
+  /**
+   * Optional metadata that provides contextual information for the input.
+   */
+  meta?: InputMetaConfig<TSpec, TOptions>;
+}
+type InputConfig<TSpec, TOptions extends object> = LoadReference | TSpec | InputFunction<TSpec, TOptions> | InputConfigObject<TSpec, TOptions>;
+type InferCreateInputOptions<T extends InputConfig<any, any>> = T extends LoadReference ? InferLoadOptions<T> : {};
+interface Input<TSpec, TOptions extends object> {
+  /**
+   * The schema that defines the structure of the specification input for the generator. This schema is used to validate the input specification and ensure that it conforms to the expected format before being processed by the generator.
+   */
+  schema: SchemaOf<TSpec, TOptions>;
+  /**
+   * Optional metadata that provides contextual information for the input.
+   */
+  meta?: InputMeta<TSpec, TOptions>;
+  /**
+   * The input of the generator, which can be used to specify where the generator retrieves its input data from. This can be defined as a function that takes the specification and returns a value, or it can be a static value.
+   *
+   * @remarks
+   * The `input` property can be either a static value of type `TSpec` or a function that takes the specification object and returns a value of type `TSpec` or a promise that resolves to `TSpec`. This allows for flexibility in how the generator retrieves its input data, enabling both synchronous and asynchronous data retrieval based on the specification.
+   *
+   * @param options - The options object that can be used to influence the generation process.
+   * @returns A value or a promise that resolves to a value, which will be used as the input data for the generator.
+   */
+  input: TSpec | InputFunction<TSpec, TOptions>;
+}
+//#endregion
+//#region src/types/execution.d.ts
+interface ExecutionSource<TSpec, TOptions extends object> {
+  /**
+   * The language of the document.
+   */
+  language?: string;
+  /**
+   * The content of the source code.
+   */
+  content: string;
+  /**
+   * The metadata of the source code.
+   */
+  meta: Meta<TSpec, TOptions>;
+}
+interface ExecutionDocument<TSpec, TOptions extends object> {
+  /**
+   * The path of the document.
+   */
+  path: string;
+  /**
+   * The source of the document.
+   */
+  source: ExecutionSource<TSpec, TOptions>[];
+  /**
+   * The metadata of the document.
+   */
+  meta: Meta<TSpec, TOptions>;
+}
+interface ExecutionMeta<TSpec, TOptions extends object> extends Meta<TSpec, TOptions> {
+  /**
+   * A unique identifier for the execution, typically used by the backend systems.
+   *
+   * @remarks
+   * This value will be in the UUID format, which is a 128-bit number represented as a string of hexadecimal digits. It is used to uniquely identify the execution in the backend systems and can be used for tracking and auditing purposes.
+   */
+  executionId: string;
+  /**
+   * The date and time when the execution was performed.
+   */
+  executedAt: Date;
+  /**
+   * The user who performed the execution.
+   */
+  executedBy: string;
+  /**
+   * The specification used to generate the source code during the execution.
+   */
+  spec: TSpec;
+  /**
+   * The metadata of the generator used to execute the source code during the execution.
+   */
+  generator: GeneratorMeta<TSpec, TOptions>;
+  /**
+   * The metadata of the schema used to generate the source code during the execution.
+   */
+  schema: SchemaMeta<TSpec, TOptions>;
+  /**
+   * The metadata of the input used to generate the source code during the execution.
+   */
+  input: InputMeta<TSpec, TOptions>;
+  /**
+   * The metadata of the output used to generate the source code during the execution.
+   */
+  output: OutputMeta<TSpec, TOptions>;
+}
+interface Execution<TSpec, TOptions extends object> {
+  /**
+   * The documents of the execution, indexed by the document path.
+   */
+  documents: Record<string, ExecutionDocument<TSpec, TOptions>>;
+  /**
+   * The metadata of the execution.
+   */
+  meta: ExecutionMeta<TSpec, TOptions>;
+}
+type ExecutionResult<TSpec, TOptions extends object, TReturns = void> = GeneratedDocument<TSpec, TOptions> & {
+  /**
+   * The returned value of the generator function.
+   */
+  returns?: TReturns;
+};
+type ExtractedExecutionSource<TSpec, TOptions extends object> = Omit<ExecutionSource<TSpec, TOptions>, "meta"> & {
+  /**
+   * The extracted metadata of the execution.
+   */
+  meta: InferExtractedMeta<ExecutionSource<TSpec, TOptions>["meta"]>;
+};
+type ExtractedExecutionDocument<TSpec, TOptions extends object> = Omit<ExecutionDocument<TSpec, TOptions>, "source" | "meta"> & {
+  /**
+   * The source of the document.
+   */
+  source: ExtractedExecutionSource<TSpec, TOptions>[];
+  /**
+   * The extracted metadata of the execution.
+   */
+  meta: InferExtractedMeta<ExecutionDocument<TSpec, TOptions>["meta"]>;
+};
+type ExtractedExecution<TSpec, TOptions extends object> = Omit<Execution<TSpec, TOptions>, "documents" | "meta"> & {
+  /**
+   * The documents of the execution, indexed by the document path.
+   */
+  documents: Record<string, ExtractedExecutionDocument<TSpec, TOptions>>;
+  /**
+   * The extracted metadata of the execution.
+   */
+  meta: InferExtractedMeta<ExecutionMeta<TSpec, TOptions>>;
+};
+//#endregion
+//#region src/types/generator.d.ts
+interface GeneratorMeta<TSpec, TOptions extends object> extends MetaConfig<TSpec, TOptions> {
+  /**
+   * A string description (or a function that returns a string) outlining the purpose or behavior of the generator.
+   */
+  description?: string;
+}
+type GeneratedDocument<TSpec, TOptions extends object> = Partial<Omit<ExecutionDocument<TSpec, TOptions>, "source">> & Pick<ExecutionDocument<TSpec, TOptions>, "path"> & {
+  /**
+   * The sources of the document.
+   */
+  source?: DeepPartial<ExecutionSource<TSpec, TOptions>>[];
+};
+type GeneratorFunction<TSpec, TOptions extends object> = (spec: TSpec, options: TOptions) => MaybePromise<Record<string, GeneratedDocument<TSpec, TOptions>>>;
+type GeneratorFunctionResult<TSpec, TOptions extends object> = Awaited<ReturnType<GeneratorFunction<TSpec, TOptions>>>;
+interface GeneratorResult<TSpec, TOptions extends object, TReturns = void> {
+  spec: TSpec;
+  options: TOptions;
+  /**
+   * The documents generated by the generator.
+   */
+  documents: GeneratorFunctionResult<TSpec, TOptions>;
+  /**
+   * The return value from the output function.
+   */
+  returns: TReturns;
+}
+interface GeneratorConfigObject<TSpec, TOptions extends object, TReturns = void> {
+  /**
+   * Optional metadata about the generator, such as a description of the output it produces.
+   */
+  meta?: GeneratorMeta<TSpec, TOptions>;
+  /**
+   * The schema config that defines the structure of the specification object for this generator.
+   */
+  schema?: SchemaConfig<TSpec> | SchemaConfigObject<TSpec, TOptions>;
+  /**
+   * The input config for the generator specification.
+   */
+  input?: InputConfig<TSpec, TOptions>;
+  /**
+   * The output config that consumes generated output.
+   */
+  output?: OutputConfig<TSpec, TOptions, TReturns>;
+  /**
+   * The generate implementation, either as a callable function or a file reference.
+   */
+  generator: GeneratorFunction<TSpec, TOptions> | LoadReference;
+}
+type GeneratorConfig<TSpec, TOptions extends object, TReturns = void> = LoadReference | GeneratorConfigObject<TSpec, TOptions, TReturns>;
+type InferCreateGeneratorOptions<T extends GeneratorConfig<any, any, any>> = T extends LoadReference ? InferLoadOptions<T> : {};
+interface Generator<TSpec, TOptions extends object, TReturns = void> {
+  /**
+   * Optional metadata about the generator, such as a description of the output it produces.
+   */
+  meta?: GeneratorMeta<TSpec, TOptions>;
+  /**
+   * The schema config that defines the structure of the specification object for this generator.
+   */
+  schema: SchemaOf<TSpec, TOptions>;
+  /**
+   * The input of the generator, which can be used to specify where the generator retrieves its input data from. This can be defined as a function that takes the specification and returns a value, or it can be a static value.
+   */
+  input: Input<TSpec, TOptions>;
+  /**
+   * The output of the generator, which can be used to specify where the generator sends its output data. This can be defined as a function that takes the specification and returns a value, or it can be a static value.
+   */
+  output: Output<TSpec, TOptions, TReturns>;
+  /**
+   * The generator function that executes the generator logic, taking in options and producing output based on the input and output definitions.
+   *
+   * @remarks
+   * The generator function is responsible for orchestrating the generation process. It takes in options that can influence the generation behavior and returns a promise that resolves to the result of the generator execution, which includes the generated output and any additional metadata.
+   *
+   * @param options - The options to be passed to the generator, which can be used to influence the generation process.
+   * @returns A promise that resolves to the result of the generator execution, which includes the generated output and any additional metadata.
+   */
+  generator: (options: TOptions & UserConfig) => Promise<GeneratorResult<TSpec, TOptions, TReturns>>;
+}
+//#endregion
+//#region src/types/output.d.ts
+type OutputFunction<TSpec, TOptions extends object, TReturns = void> = (spec: TSpec, options: TOptions, documents: Record<string, GeneratedDocument<TSpec, TOptions>>) => MaybePromise<TReturns>;
+interface OutputMetaConfig<TSpec, TOptions extends object> extends MetaConfig<TSpec, TOptions> {
+  /**
+   * A string that describes how the specification will be extracted or generated. This property can provide context about the source of the specification, such as whether it is derived from a file, a database, an API, or any other source. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  produces?: string;
+}
+interface OutputMeta<TSpec, TOptions extends object> extends Meta<TSpec, TOptions> {
+  /**
+   * A string that describes how the specification will be extracted or generated. This property can provide context about the source of the specification, such as whether it is derived from a file, a database, an API, or any other source. The presence of this property does not affect the validation behavior of the schema itself, but it can provide additional context or information about the expected data when used in conjunction with compatible tools.
+   */
+  produces?: string;
+}
+interface OutputConfigObject<TSpec, TOptions extends object, TReturns = void> {
+  /**
+   * The schema that defines the structure of the specification output for the generator. This schema is used to validate the output specification and ensure that it conforms to the expected format before being processed by the generator.
+   */
+  schema?: SchemaConfig<TSpec> | SchemaConfigObject<TSpec, TOptions>;
+  /**
+   * Optional metadata that provides contextual information for the output.
+   */
+  meta?: OutputMetaConfig<TSpec, TOptions>;
+  /**
+   * The output implementation, either as a callable function or a file reference.
+   */
+  output: OutputFunction<TSpec, TOptions, TReturns> | LoadReference;
+}
+type OutputConfig<TSpec, TOptions extends object, TReturns = void> = LoadReference | OutputFunction<TSpec, TOptions, TReturns> | OutputConfigObject<TSpec, TOptions, TReturns>;
+type InferCreateOutputOptions<T extends OutputConfig<any, any, any>> = T extends LoadReference ? InferLoadOptions<T> : {};
+interface Output<TSpec, TOptions extends object, TReturns = void> {
+  /**
+   * The schema that defines the structure of the specification output for the generator. This schema is used to validate the output specification and ensure that it conforms to the expected format before being processed by the generator.
+   */
+  schema: SchemaOf<TSpec, TOptions>;
+  /**
+   * Optional metadata that provides contextual information for the output.
+   */
+  meta?: OutputMeta<TSpec, TOptions>;
+  /**
+   * The output of the generator, which can be used to specify where the generator sends its output data. This can be defined as a function that takes the specification and returns a value, or it can be a static value.
+   *
+   * @remarks
+   * The `output` property is defined as a function that takes the specification object and any additional parameters, and returns a value or a promise that resolves to a value. This allows for flexibility in how the generator sends its output data, enabling both synchronous and asynchronous data handling based on the specification.
+   *
+   * @param spec - The specification object that conforms to the defined schema output.
+   * @param options - Additional parameters that may be needed for the output function to process the output data.
+   * @param documents - An array of generated documents that are produced by the generator. This can be used to provide context or additional information to the output function when processing the output data.
+   * @returns A promise that resolves when the output function is complete.
+   */
+  output: OutputFunction<TSpec, TOptions, TReturns>;
+}
+//#endregion
+//#region src/types/settings.d.ts
+interface Settings {
+  /**
+   * The mode to use for the application.
+   *
+   * @defaultValue "production"
+   */
+  mode: "development" | "production" | "test";
+  /**
+   * The log level to use for the application.
+   *
+   * @defaultValue "warn"
+   */
+  logLevel: "debug" | "info" | "warn" | "error" | "silent";
+  /**
+   * The paths to use for the application.
+   */
+  paths: EnvPaths;
+  /**
+   * Whether to skip {@link Execution | execution metadata} storage after completing generation.
+   *
+   * @defaultValue false
+   */
+  skipStorage: boolean;
+}
+interface Logger {
+  debug: (message: string) => void;
+  info: (message: string) => void;
+  warn: (message: string) => void;
+  error: (message: string) => void;
+}
+//#endregion
+//#region src/types/config.d.ts
+interface UserConfig<TSpec = any, TOptions extends object = any, TReturns = any> {
+  /**
+   * The current working directory.
+   *
+   * @defaultValue process.cwd()
+   */
+  cwd?: string;
+  /**
+   * Whether to enable debug mode.
+   */
+  debug?: true;
+  /**
+   * The settings to use for the application.
+   */
+  settings?: DeepPartial<Settings>;
+  /**
+   * The default [Unstorage](https://unstorage.unjs.io) storage instance to use for the application.
+   *
+   * @remarks
+   * If not provided, a default storage instance will be created. If provided, it will be used for all input and output operations. This allows for a single storage instance to be used across the entire application. If you want to use different storage instances for different inputs and outputs, you can provide them in the input and output configurations instead of here.
+   */
+  storage?: Storage;
+  /**
+   * The logger to use for the application.
+   */
+  logger?: Partial<Logger>;
+  /**
+   * The input config that will override the generator's input.
+   */
+  input?: InputConfig<TSpec, TOptions>;
+  /**
+   * The output config that will override the generator's output.
+   */
+  output?: OutputConfig<TSpec, TOptions, TReturns>;
+}
+interface UserConfigParams {
+  cwd: string;
+  mode: string;
+}
+type UserConfigFnObject<TSpec = any, TOptions extends object = any, TReturns = any> = (config: UserConfig<TSpec, TOptions, TReturns>) => UserConfig<TSpec, TOptions, TReturns>;
+type UserConfigFnPromise<TSpec = any, TOptions extends object = any, TReturns = any> = (params: UserConfigParams) => Promise<UserConfig<TSpec, TOptions, TReturns> | UserConfig<TSpec, TOptions, TReturns>[]>;
+type UserConfigFn<TSpec = any, TOptions extends object = any, TReturns = any> = (params: UserConfigParams) => UserConfig<TSpec, TOptions, TReturns> | UserConfig<TSpec, TOptions, TReturns>[] | Promise<UserConfig<TSpec, TOptions, TReturns> | UserConfig<TSpec, TOptions, TReturns>[]>;
+type UserConfigExport<TSpec = any, TOptions extends object = any, TReturns = any> = UserConfig<TSpec, TOptions, TReturns> | UserConfig<TSpec, TOptions, TReturns>[] | Promise<UserConfig<TSpec, TOptions, TReturns> | UserConfig<TSpec, TOptions, TReturns>[]> | UserConfigFnObject<TSpec, TOptions, TReturns> | UserConfigFnPromise<TSpec, TOptions, TReturns> | UserConfigFn<TSpec, TOptions, TReturns>;
+//#endregion
+export { MetaDataPrimitive as $, ExtractedExecution as A, InferCreateSchemaOptions as B, GeneratorResult as C, ExecutionMeta as D, ExecutionDocument as E, InputConfig as F, SchemaMetaExample as G, SchemaConfigObject as H, InputConfigObject as I, InferExtractedMeta as J, SchemaOf as K, InputFunction as L, ExtractedExecutionSource as M, InferCreateInputOptions as N, ExecutionResult as O, Input as P, MetaData as Q, InputMeta as R, GeneratorMeta as S, Execution as T, SchemaMeta as U, Schema as V, SchemaMetaConfig as W, Meta as X, InferExtractedMetaDataRecord as Y, MetaConfig as Z, Generator as _, UserConfigFnPromise as a, GeneratorFunction as b, Settings as c, OutputConfig as d, MetaDataRecord as et, OutputConfigObject as f, GeneratedDocument as g, OutputMetaConfig as h, UserConfigFnObject as i, ExtractedExecutionDocument as j, ExecutionSource as k, InferCreateOutputOptions as l, OutputMeta as m, UserConfigExport as n, MetaLink as nt, UserConfigParams as o, OutputFunction as p, BaseMeta as q, UserConfigFn as r, MetaValue as rt, Logger as s, UserConfig as t, MetaDeprecated as tt, Output as u, GeneratorConfig as v, InferCreateGeneratorOptions as w, GeneratorFunctionResult as x, GeneratorConfigObject as y, InputMetaConfig as z };
+//# sourceMappingURL=config-B6Gr29ZK.d.mts.map

package/dist/config-B6Gr29ZK.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-B6Gr29ZK.d.mts","names":[],"sources":["../src/types/meta.ts","../src/types/schema.ts","../src/types/input.ts","../src/types/execution.ts","../src/types/generator.ts","../src/types/output.ts","../src/types/settings.ts","../src/types/config.ts"],"mappings":""}

package/dist/config.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});function e(e){return e}exports.defineConfig=e;

package/dist/config.d.cts

@@ -0,0 +1,34 @@
+import { a as UserConfigFnPromise, i as UserConfigFnObject, n as UserConfigExport, o as UserConfigParams, r as UserConfigFn, t as UserConfig } from "./config-B6Gr29ZK.cjs";
+
+//#region src/config.d.ts
+/**
+ * Type helper to make it easier to use `power-plant.config.ts` files. Accepts a direct {@link UserConfig} object, or a function that returns it. The function receives a {@link ConfigParams} object.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from '@power-plant/core';
+ *
+ * export default defineConfig({
+ *   // Your configuration here
+ * });
+ *
+ * // Or with a function
+ * export default defineConfig((env) => {
+ *   console.log(`Running command: ${env.command} in mode: ${env.mode}`);
+ *   return {
+ *     // Your configuration here
+ *   };
+ * });
+ * ```
+ */
+declare function defineConfig(config: UserConfig): UserConfig;
+declare function defineConfig(config: UserConfig[]): UserConfig[];
+declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+declare function defineConfig(config: Promise<UserConfig[]>): Promise<UserConfig[]>;
+declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+declare function defineConfig(config: UserConfigFnPromise): UserConfigFnPromise;
+declare function defineConfig(config: UserConfigFn): UserConfigFn;
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+//#endregion
+export { type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type UserConfigParams, defineConfig };
+//# sourceMappingURL=config.d.cts.map

package/dist/config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"mappings":";;;;AAgDA;;;;;;;;AAA4D;AAC5D;;;;;;;;AAA8D;AAC9D;iBAFgB,YAAA,CAAa,MAAA,EAAQ,UAAA,GAAa,UAAU;AAAA,iBAC5C,YAAA,CAAa,MAAA,EAAQ,UAAA,KAAe,UAAU;AAAA,iBAC9C,YAAA,CAAa,MAAA,EAAQ,OAAA,CAAQ,UAAA,IAAc,OAAA,CAAQ,UAAA;AAAA,iBACnD,YAAA,CACd,MAAA,EAAQ,OAAA,CAAQ,UAAA,MACf,OAAA,CAAQ,UAAA;AAAA,iBACK,YAAA,CAAa,MAAA,EAAQ,kBAAA,GAAqB,kBAAkB;AAAA,iBAC5D,YAAA,CAAa,MAAA,EAAQ,mBAAA,GAAsB,mBAAmB;AAAA,iBAC9D,YAAA,CAAa,MAAA,EAAQ,YAAA,GAAe,YAAY;AAAA,iBAChD,YAAA,CAAa,MAAA,EAAQ,gBAAA,GAAmB,gBAAgB"}

package/dist/config.d.mts

@@ -0,0 +1,34 @@
+import { a as UserConfigFnPromise, i as UserConfigFnObject, n as UserConfigExport, o as UserConfigParams, r as UserConfigFn, t as UserConfig } from "./config-B6Gr29ZK.mjs";
+
+//#region src/config.d.ts
+/**
+ * Type helper to make it easier to use `power-plant.config.ts` files. Accepts a direct {@link UserConfig} object, or a function that returns it. The function receives a {@link ConfigParams} object.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from '@power-plant/core';
+ *
+ * export default defineConfig({
+ *   // Your configuration here
+ * });
+ *
+ * // Or with a function
+ * export default defineConfig((env) => {
+ *   console.log(`Running command: ${env.command} in mode: ${env.mode}`);
+ *   return {
+ *     // Your configuration here
+ *   };
+ * });
+ * ```
+ */
+declare function defineConfig(config: UserConfig): UserConfig;
+declare function defineConfig(config: UserConfig[]): UserConfig[];
+declare function defineConfig(config: Promise<UserConfig>): Promise<UserConfig>;
+declare function defineConfig(config: Promise<UserConfig[]>): Promise<UserConfig[]>;
+declare function defineConfig(config: UserConfigFnObject): UserConfigFnObject;
+declare function defineConfig(config: UserConfigFnPromise): UserConfigFnPromise;
+declare function defineConfig(config: UserConfigFn): UserConfigFn;
+declare function defineConfig(config: UserConfigExport): UserConfigExport;
+//#endregion
+export { type UserConfig, type UserConfigExport, type UserConfigFn, type UserConfigFnObject, type UserConfigFnPromise, type UserConfigParams, defineConfig };
+//# sourceMappingURL=config.d.mts.map

package/dist/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../src/config.ts"],"mappings":""}

package/dist/config.mjs

@@ -0,0 +1,2 @@
+function e(e){return e}export{e as defineConfig};
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":[],"mappings":""}