@caeljs/config/dist/index.d.ts

Simple system of standardization of configurations for node js and bun.

// Generated by dts-bundle-generator v9.5.1

import { ArrayOptions, NumberOptions, ObjectOptions, SchemaOptions, Static, StringOptions, TLiteral, TObject, TProperties, TSchema, TUnion } from '@sinclair/typebox';

declare class ConfigJSDriver<C extends DriverConfig, S extends DriverStore, Async extends boolean> {
	readonly identify: string;
	async: Async;
	config: C;
	data: Record<string, any>;
	comments?: Record<string, string>;
	private compiledSchema?;
	protected store: S;
	_onLoad?(schema: SchemaDefinition, opts: Partial<C>): inPromise<Async, any>;
	private _onSet?;
	private _onDel?;
	protected buildDefaultObject: typeof buildDefaultObject;
	protected deepMerge: typeof deepMerge;
	constructor(options: ConfigJSDriverOptions<C, S, Async>);
	load(schema: SchemaDefinition, options?: Partial<C>): inPromise<Async, void>;
	get<T = StaticSchema<any>, P extends Paths<T> = any>(path: P): inPromise<Async, DeepGet<T, P>>;
	has<T = StaticSchema<any>, P extends Paths<T> = any>(...paths: P[]): inPromise<Async, boolean>;
	set<T = StaticSchema<any>, P extends Paths<T> = any>(path: P, value: DeepGet<T, P>, options?: {
		description?: string;
	}): inPromise<Async, void>;
	insert<T = StaticSchema<any>, P extends RootPaths<T> = any>(path: P, partial: Partial<DeepGet<T, P>>): inPromise<Async, void>;
	del<T = StaticSchema<any>, P extends Paths<T> = any>(path: P): inPromise<Async, void>;
	private validate;
}
declare function buildDefaultObject(definition: SchemaDefinition): Record<string, any>;
declare function deepMerge<T extends object, U extends object>(target: T, source: U): T & U;
export declare class ConfigJS<D extends ConfigJSDriver<any, any, any>, S extends SchemaDefinition> {
	private driver;
	private schema;
	private loaded;
	constructor(driver: D, schema: S);
	/**
	 * Loads the configuration.
	 * @param options - The loading options.
	 */
	load(options?: D["config"] & {
		/**
		 * If true, all schema properties will be treated as optional during validation,
		 * except for those marked as `important: true`. This is useful for loading a
		 * partial configuration without triggering validation errors for missing values.
		 */
		only_importants?: boolean;
	}): inPromise<D["async"], void>;
	get<P extends Paths<StaticSchema<S>>>(path: P): inPromise<D["async"], DeepGet<StaticSchema<S>, P>>;
	has<P extends Paths<StaticSchema<S>>>(...paths: P[]): inPromise<D["async"], boolean>;
	root<P extends RootPaths<StaticSchema<S>>>(path: P): inPromise<D["async"], DeepGet<StaticSchema<S>, P>>;
	set<P extends Paths<StaticSchema<S>>>(path: P, value: DeepGet<StaticSchema<S>, P>, options?: {
		description?: string;
	}): inPromise<D["async"], void>;
	insert<P extends RootPaths<StaticSchema<S>>>(path: P, partial: Partial<DeepGet<StaticSchema<S>, P>>): inPromise<D["async"], void>;
	del<P extends Paths<StaticSchema<S>>>(path: P): inPromise<D["async"], void>;
	conf<P extends Paths<StaticSchema<S>>>(path: P): DeepGet<S, P>;
}
/**
 * A helper object for creating schema definitions with custom metadata.
 * Includes both PascalCase and camelCase versions of helpers.
 */
export declare const c: {
	string: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	number: <TDefault extends number>(options?: NumberOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TNumber;
	boolean: <TDefault extends boolean>(options?: Omit<SchemaOptions, "default"> & CustomOptions<TDefault>) => import("@sinclair/typebox").TBoolean;
	object: <Properties extends TProperties, TDefault extends Record<string, any>>(properties: Properties, options?: ObjectOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TObject<Properties>;
	array: <Schema extends TSchema, TDefault extends any[]>(items: Schema, options?: ArrayOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TArray<Schema>;
	record: <K extends TSchema, V extends TSchema, TDefault extends Record<string, any>>(key: K, value: V, options?: Omit<SchemaOptions, "default"> & CustomOptions<TDefault>) => import("@sinclair/typebox").TRecordOrObject<K, V>;
	enum: <T extends readonly (string | number)[] | object, TValues = T extends readonly (infer U)[] ? U : T extends object ? T[keyof T] : never>(values: T, options?: CustomOptions<TValues> & Omit<SchemaOptions, "default">) => TUnion<TLiteral<TValues>[]>;
	ip: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	ipv6: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	email: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	url: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	any: () => import("@sinclair/typebox").TAny;
	optional: <Schema extends TSchema>(schema: Schema) => Schema extends import("@sinclair/typebox").TOptional<infer S extends TSchema> ? import("@sinclair/typebox").TOptional<S> : import("@sinclair/typebox").Ensure<import("@sinclair/typebox").TOptional<Schema>>;
	/** Creates a String schema. */
	String: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	/** Creates a Number schema. */
	Number: <TDefault extends number>(options?: NumberOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TNumber;
	/** Creates a Boolean schema. */
	Boolean: <TDefault extends boolean>(options?: Omit<SchemaOptions, "default"> & CustomOptions<TDefault>) => import("@sinclair/typebox").TBoolean;
	/** Creates an Object schema. */
	Object: <Properties extends TProperties, TDefault extends Record<string, any>>(properties: Properties, options?: ObjectOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TObject<Properties>;
	/** Creates an Array schema. */
	Array: <Schema extends TSchema, TDefault extends any[]>(items: Schema, options?: ArrayOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TArray<Schema>;
	/** Creates a Record schema. */
	Record: <K extends TSchema, V extends TSchema, TDefault extends Record<string, any>>(key: K, value: V, options?: Omit<SchemaOptions, "default"> & CustomOptions<TDefault>) => import("@sinclair/typebox").TRecordOrObject<K, V>;
	/** Creates a Union of Literals from a string array, const array, or a TypeScript enum. */
	Enum: <T extends readonly (string | number)[] | object, TValues = T extends readonly (infer U)[] ? U : T extends object ? T[keyof T] : never>(values: T, options?: CustomOptions<TValues> & Omit<SchemaOptions, "default">) => TUnion<TLiteral<TValues>[]>;
	/** Creates a string schema with 'ipv4' format. */
	IP: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	/** Creates a string schema with 'ipv6' format. */
	IPv6: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	/** Creates a string schema with 'email' format. */
	Email: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	/** Creates a string schema with 'uri' format. */
	URL: <TDefault extends string>(options?: StringOptions & CustomOptions<TDefault>) => import("@sinclair/typebox").TString;
	/** Creates an Any schema. */
	Any: () => import("@sinclair/typebox").TAny;
	/** Creates an Optional schema. */
	Optional: <Schema extends TSchema>(schema: Schema) => Schema extends import("@sinclair/typebox").TOptional<infer S extends TSchema> ? import("@sinclair/typebox").TOptional<S> : import("@sinclair/typebox").Ensure<import("@sinclair/typebox").TOptional<Schema>>;
};
export declare const envDriver: ConfigJSDriver<{
	path: string;
}, DriverStore, false>;
export declare const jsonDriver: ConfigJSDriver<{
	path: string;
	keyroot: boolean;
}, DriverStore, false>;
export interface ConfigJSDriverOptions<C extends DriverConfig, S extends DriverStore, A extends boolean> {
	identify: string;
	async: A;
	config: C;
	getEnvKeyForPath?: (path: string) => string;
	onLoad?: DriverOnLoad<C, S, A>;
	onSet?: DriverOnSet<C, S, A>;
	onDel?: DriverOnDel<C, S, A>;
}
/**
 * Custom metadata properties that can be added to a schema.
 */
export interface CustomOptions<Default = any> {
	description?: string;
	default?: Default;
	important?: boolean;
	initial_save?: boolean;
	prop?: string;
	refines?: ((value: unknown) => boolean | string)[];
}
export type DeepGet<T, P extends string> = P extends `${infer K}.${infer R}` ? K extends keyof T ? DeepGet<T[K], R> : never : P extends keyof T ? T[P] : never;
export type DriverConfig = Record<string, unknown>;
export type DriverOnDel<C extends DriverConfig, S extends DriverStore, A extends boolean> = (this: ConfigJSDriver<C, S, A>, key: string) => inPromise<A, void>;
export type DriverOnLoad<C extends DriverConfig, S extends DriverStore, A extends boolean> = (this: ConfigJSDriver<C, S, A>, schema: SchemaDefinition, opts: Partial<C>) => inPromise<A, any>;
export type DriverOnSet<C extends DriverConfig, S extends DriverStore, A extends boolean> = (this: ConfigJSDriver<C, S, A>, key: string, value: unknown, options?: {
	description?: string;
}) => inPromise<A, void>;
export type DriverStore = Record<string, unknown>;
export type Paths<T> = T extends object ? {
	[K in keyof T]: K extends string ? T[K] extends ReadonlyArray<any> ? K : T[K] extends object ? `${K}.${Paths<T[K]>}` | K : K : never;
}[keyof T] : never;
export type RootPaths<T> = T extends object ? {
	[K in keyof T]: K extends string ? T[K] extends ReadonlyArray<any> ? K : T[K] extends object ? K | `${K}.${RootPaths<T[K]>}` : never : never;
}[keyof T] : never;
/**
 * A recursive type representing the user-friendly schema definition.
 */
export type SchemaDefinition = TSchema | {
	[key: string]: SchemaDefinition;
};
/**
 * A mapped type que converte um SchemaDefinition em tipo estático TypeScript.
 * Agora com suporte a arrays do TypeBox.
 */
export type StaticSchema<T> = T extends {
	type: "array";
	items: infer I;
} ? StaticSchema<I>[] : T extends TSchema ? Static<T> : T extends SchemaDefinition ? {
	-readonly [K in keyof T]: StaticSchema<T[K]>;
} : never;
export type inPromise<Async extends boolean, Result> = Async extends true ? Promise<Result> : Result;

export {
	TObject,
	TSchema,
};

export {};