@tstdl/base 0.92.122 → 0.92.124

package/templates/renderers/handlebars.template-renderer.d.ts

@@ -1,43 +0,0 @@
-import type { ObjectLiteral, Record } from '../../types.js';
-import type * as Handlebars from 'handlebars';
-import { TemplateResolverProvider } from '../template-resolver.provider.js';
-import type { TemplateField } from '../template.model.js';
-import type { TemplateRenderObject } from '../template.renderer.js';
-import { TemplateRenderer } from '../template.renderer.js';
-export type HandlebarsTemplateHelperOptionsLocationItem = {
-    line: number;
-    column: number;
-};
-export type HandlebarsTemplateHelperOptionsLocation = {
-    start: HandlebarsTemplateHelperOptionsLocationItem;
-    end: HandlebarsTemplateHelperOptionsLocationItem;
-};
-export type HandlebarsTemplateHelperOptions = {
-    name: string;
-    location?: HandlebarsTemplateHelperOptionsLocation;
-    data?: Record<string>;
-    hash: Record<string>;
-    lookupProperty: (object: ObjectLiteral, propertyName: string) => unknown;
-    fn?: Handlebars.TemplateDelegate;
-    inverse?: Handlebars.TemplateDelegate;
-};
-export type HandlebarsTemplateHelper = (context: unknown, args: unknown[], options: HandlebarsTemplateHelperOptions) => any;
-export type HandlebarsTemplateHelpersObject = Record<string, HandlebarsTemplateHelper>;
-export type HandlebarsTemplatePartial = string | TemplateField<string, 'handlebars', HandlebarsRendererOptions> | Handlebars.TemplateDelegate;
-export type HandlebarsTemplatePartialsObject = Record<string, HandlebarsTemplatePartial>;
-export type HandlebarsRendererOptions = {
-    strict?: boolean;
-    preventIndent?: boolean;
-    helpers?: HandlebarsTemplateHelpersObject;
-    partials?: HandlebarsTemplatePartialsObject;
-};
-export type HandlebarsTemplateRenderObject = TemplateRenderObject<'handlebars', HandlebarsRendererOptions>;
-export declare class HandlebarsTemplateRenderer extends TemplateRenderer<'handlebars', HandlebarsRendererOptions> {
-    private readonly templateResolverProvider;
-    private readonly compileHandlebarsTemplate;
-    constructor(templateResolverProvider: TemplateResolverProvider);
-    canHandleType(type: string): boolean;
-    _render(renderObject: HandlebarsTemplateRenderObject, context: Record): Promise<string>;
-    private _compileHandlebarsTemplate;
-    private normalizePartial;
-}

package/templates/renderers/jsx.template-renderer.d.ts

@@ -1,10 +0,0 @@
-import type { Record } from '../../types.js';
-import type { JsxTemplate } from '../resolvers/jsx.template-resolver.js';
-import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
-import { TemplateRenderer } from '../template.renderer.js';
-export type JsxTemplateRenderObject = TemplateRenderObject<'jsx', undefined, JsxTemplate>;
-export declare class JsxTemplateRenderer extends TemplateRenderer<'jsx', undefined> {
-    constructor();
-    canHandleType(type: string): boolean;
-    _render({ template }: JsxTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
-}

package/templates/renderers/mjml.template-renderer.d.ts

@@ -1,16 +0,0 @@
-import type { Record } from '../../types.js';
-import type { MJMLParsingOptions } from 'mjml-core';
-import { TemplateRendererProvider } from '../template-renderer.provider.js';
-import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
-import { TemplateRenderer } from '../template.renderer.js';
-export type MjmlRendererOptions = Pick<MJMLParsingOptions, 'fonts' | 'keepComments' | 'validationLevel'> & {
-    preprocessorOptions?: any;
-};
-export type MjmlRendererString = 'mjml' | `mjml-${string}`;
-export type MjmlTemplateRenderObject = TemplateRenderObject<MjmlRendererString, MjmlRendererOptions, string>;
-export declare class MjmlTemplateRenderer extends TemplateRenderer<MjmlRendererString, MjmlRendererOptions> {
-    private readonly rendererProvider;
-    constructor(rendererProvider: TemplateRendererProvider);
-    canHandleType(type: string): boolean;
-    _render({ renderer, template, options }: MjmlTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
-}

package/templates/renderers/string.template-renderer.d.ts

@@ -1,10 +0,0 @@
-import type { Record } from '../../types.js';
-import type { StringTemplate } from '../resolvers/string.template-resolver.js';
-import type { TemplateRenderObject, TemplateRenderResult } from '../template.renderer.js';
-import { TemplateRenderer } from '../template.renderer.js';
-export type StringTemplateRenderObject = TemplateRenderObject<'string', undefined, StringTemplate>;
-export declare class StringTemplateRenderer extends TemplateRenderer<'string', undefined> {
-    constructor();
-    canHandleType(type: string): boolean;
-    _render({ template }: StringTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
-}

package/templates/resolvers/file.template-resolver.d.ts

@@ -1,22 +0,0 @@
-import { type Resolvable, resolveArgumentType } from '../../injector/interfaces.js';
-import type { TypedOmit } from '../../types.js';
-import { TemplateField } from '../template.model.js';
-import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
-import { TemplateResolver } from '../template.resolver.js';
-export type FileTemplateProviderConfig = {
-    basePath?: string;
-};
-export type FileTemplateProviderArgument = string;
-export declare const fileTemplateProviderConfig: FileTemplateProviderConfig;
-export declare class FileTemplateField<Renderer extends string = string, Options = any> extends TemplateField<'file', Renderer, Options> {
-    templateFile: string;
-}
-export declare class FileTemplateResolver extends TemplateResolver<FileTemplateField> implements Resolvable<FileTemplateProviderArgument> {
-    private readonly basePath;
-    readonly [resolveArgumentType]: FileTemplateProviderArgument;
-    constructor(basePath: string);
-    canHandle(resolver: string): boolean;
-    resolve(field: FileTemplateField): Promise<string>;
-}
-export declare function fileTemplateField<Renderer extends TemplateRenderer>(field: TypedOmit<FileTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>, 'resolver'>): FileTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions]>;
-export declare function configureFileTemplateResolver(config?: Partial<FileTemplateProviderConfig>): void;

package/templates/resolvers/jsx.template-resolver.d.ts

@@ -1,17 +0,0 @@
-import type { PartialProperty, Record, TypedOmit } from '../../types.js';
-import type { ComponentClass, FunctionComponent } from 'preact';
-import { type Template, TemplateField } from '../template.model.js';
-import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
-import { TemplateResolver } from '../template.resolver.js';
-export type JsxTemplate<Context extends Record = any> = FunctionComponent<Context> | ComponentClass<Context, any>;
-export declare class JsxTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
-    template: JsxTemplate<Context>;
-}
-export declare class JsxTemplateResolver extends TemplateResolver<JsxTemplateField, JsxTemplate> {
-    canHandle(resolver: string): boolean;
-    resolve(field: JsxTemplateField): JsxTemplate;
-}
-export declare function jsxTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: PartialProperty<TypedOmit<JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>, 'renderer'>): JsxTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;
-export declare function simpleJsxTemplate<Context extends Record = any>(name: string, template: JsxTemplate<Context>): Template<{
-    template: true;
-}, undefined, Context>;

package/templates/resolvers/string.template-resolver.d.ts

@@ -1,13 +0,0 @@
-import type { Record, TypedOmit } from '../../types.js';
-import { TemplateField } from '../template.model.js';
-import type { TemplateRenderer, TemplateRendererOptions, TemplateRendererString } from '../template.renderer.js';
-import { TemplateResolver } from '../template.resolver.js';
-export type StringTemplate<Context extends Record = any> = string | ((context: Context) => string | Promise<string>);
-export declare class StringTemplateField<Renderer extends string = string, Options = any, Context extends Record = any> extends TemplateField<'string', Renderer, Options, Context> {
-    template: StringTemplate<Context>;
-}
-export declare class StringTemplateResolver extends TemplateResolver<StringTemplateField> {
-    canHandle(resolver: string): boolean;
-    resolve(field: StringTemplateField): StringTemplate<Record>;
-}
-export declare function stringTemplateField<Renderer extends TemplateRenderer, Context extends Record = any>(field: TypedOmit<StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>, 'resolver'>): StringTemplateField<Renderer[TemplateRendererString], Renderer[TemplateRendererOptions], Context>;

package/templates/template.model.d.ts

@@ -1,25 +0,0 @@
-import type { PickBy, Record, SimplifyObject } from '../types.js';
-export type TemplateContext<T extends Template> = Parameters<NonNullable<T[typeof templateContext]>>[0];
-declare const templateContext: unique symbol;
-export declare class TemplateField<Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> {
-    readonly [templateContext]?: (context: Context) => void;
-    resolver: Resolver;
-    renderer: Renderer;
-    options?: Options;
-}
-export type TemplateFields<Fields extends Record<string, boolean>, Resolver extends string = string, Renderer extends string = string, Options = any, Context extends Record = any> = SimplifyObject<{
-    [P in keyof PickBy<Fields, true>]: TemplateField<Resolver, Renderer, Options, Context>;
-} & {
-    [P in keyof PickBy<Fields, false>]?: TemplateField<Resolver, Renderer, Options, Context>;
-}>;
-export declare abstract class Template<Fields extends Record<string, boolean> = Record<string, boolean>, TemplateOptions = any, Context extends Record = any> {
-    readonly [templateContext]?: (context: Context) => void;
-    /** Name of template */
-    name: string;
-    fields: TemplateFields<Fields, string, string, any, Context>;
-    options?: TemplateOptions;
-}
-export declare function simpleTemplate<Context extends Record = any, Options = any>(name: string, template: TemplateField<string, string, any, Context>, options?: Options): Template<{
-    template: true;
-}, Options, Context>;
-export {};

package/templates/template.renderer.d.ts

@@ -1,20 +0,0 @@
-import type { SchemaTestable } from '../schema/index.js';
-import type { Record } from '../types.js';
-export type TemplateRenderResult = string;
-export type TemplateRenderObject<Renderer extends string = string, Options = any, V = unknown> = {
-    renderer: Renderer;
-    template: V;
-    contextSchema?: SchemaTestable<Record>;
-    options?: Options;
-};
-export type TemplateRendererString = typeof templateRendererString;
-export type TemplateRendererOptions = typeof templateRendererOptions;
-export declare const templateRendererString: unique symbol;
-export declare const templateRendererOptions: unique symbol;
-export declare abstract class TemplateRenderer<Renderer extends string = string, Options = any> {
-    readonly [templateRendererString]: Renderer;
-    readonly [templateRendererOptions]: Options;
-    render(template: TemplateRenderObject<Renderer, Options>, context?: Record): Promise<TemplateRenderResult>;
-    abstract canHandleType(type: string): boolean;
-    protected abstract _render(renderObject: TemplateRenderObject<Renderer, Options>, context: Record): TemplateRenderResult | Promise<TemplateRenderResult>;
-}

package/templates/template.service.d.ts

@@ -1,18 +0,0 @@
-import type { Record } from '../types.js';
-import { TemplateRendererProvider } from './template-renderer.provider.js';
-import { TemplateResolverProvider } from './template-resolver.provider.js';
-import type { Template, TemplateContext } from './template.model.js';
-import { TemplateProvider } from './template.provider.js';
-export type TemplateServiceRenderResult<T extends Template = Template> = {
-    name: string;
-    fields: Record<keyof T['fields'], string>;
-    options: T['options'];
-};
-export declare class TemplateService {
-    private readonly templateProvider;
-    private readonly templateRendererProvider;
-    private readonly templateResolverProvider;
-    constructor(templateProvider: TemplateProvider | undefined, templateRendererProvider: TemplateRendererProvider, templateResolverProvider: TemplateResolverProvider);
-    get<T extends Template = Template>(key: string): Promise<T>;
-    render<T extends Template = Template>(keyOrTemplate: string | T, templateContext?: TemplateContext<T>): Promise<TemplateServiceRenderResult<T>>;
-}

package/templates/tokens.d.ts

@@ -1,4 +0,0 @@
-import type { TemplateRenderer } from './template.renderer.js';
-import type { TemplateResolver } from './template.resolver.js';
-export declare const TEMPLATE_RENDERERS: import("../injector/token.js").InjectionToken<TemplateRenderer<string, any>[], never>;
-export declare const TEMPLATE_RESOLVERS: import("../injector/token.js").InjectionToken<TemplateResolver<import("./template.model.js").TemplateField<string, string, any, any>, unknown>[], never>;

package/text/dynamic-text.model.d.ts

@@ -1,15 +0,0 @@
-import { type Observable } from 'rxjs';
-import { type Signal } from '../signals/api.js';
-import type { PickBy, ReactiveValue, ReplaceKey } from '../types.js';
-import type { LocalizableText } from './localizable-text.model.js';
-import { LocalizationService } from './localization.service.js';
-export type DynamicText = ReactiveValue<LocalizableText>;
-export declare const missingLocalizationKeyText = "[MISSING LOCALIZATION KEY]";
-export declare function resolveDynamicText(text: DynamicText, localizationService?: LocalizationService): Signal<string>;
-export declare function resolveDynamicText$(text: DynamicText, localizationService?: LocalizationService): Observable<string>;
-export declare function resolveDynamicTexts(texts: DynamicText[], localizationService?: LocalizationService): Signal<string[]>;
-export declare function resolveDynamicTexts$(texts: DynamicText[], localizationService?: LocalizationService): Observable<string[]>;
-export declare function resolveNestedDynamicText<T, K extends keyof PickBy<T, DynamicText>>(item: T, key: K, localizationService?: LocalizationService): Signal<ReplaceKey<T, K, string>>;
-export declare function resolveNestedDynamicText$<T, K extends keyof PickBy<T, DynamicText>>(item: T, key: K, localizationService?: LocalizationService): Observable<ReplaceKey<T, K, string>>;
-export declare function resolveNestedDynamicTexts<T, K extends keyof PickBy<T, DynamicText>>(items: T[], key: K, localizationService?: LocalizationService): Signal<ReplaceKey<T, K, string>[]>;
-export declare function resolveNestedDynamicTexts$<T, K extends keyof PickBy<T, DynamicText>>(items: T[], key: K, localizationService?: LocalizationService): Observable<ReplaceKey<T, K, string>[]>;

package/text/localization.service.d.ts

@@ -1,92 +0,0 @@
-import type { Observable } from 'rxjs';
-import { Logger } from '../logger/index.js';
-import type { Signal } from '../signals/api.js';
-import type { Enumeration, EnumerationValue, Record } from '../types.js';
-import type { PropertyName } from '../utils/object/property-name.js';
-export type Language = {
-    code: string;
-    name: string;
-};
-export type LocalizeFunctionContext = {
-    localizationService: LocalizationService;
-};
-export type LocalizeFunction<Parameters = void> = (parameters: Parameters, context: LocalizeFunctionContext) => string;
-export type LocalizeItem<Parameters = void> = string | LocalizeFunction<Parameters>;
-type LocalizationTemplate = {
-    [key: string]: LocalizeItem<any> | LocalizationTemplate;
-};
-export type EnumerationLocalization<T extends Enumeration = Enumeration> = Record<EnumerationValue<T>, LocalizeItem<any>>;
-export type EnumerationLocalizationEntry<T extends Enumeration = Enumeration> = [enumType: T, enumName: LocalizeItem<any> | undefined, enumValues: EnumerationLocalization<T>];
-export type Localization<T extends LocalizationTemplate = LocalizationTemplate, Enums extends Enumeration[] = Enumeration[]> = {
-    language: Language;
-    keys: T;
-    enums: {
-        [I in keyof Enums]: EnumerationLocalizationEntry<Enums[I]>;
-    };
-};
-declare const parametersSymbol: unique symbol;
-export type ProxyLocalizationKey<Parameters = void> = PropertyName & {
-    [parametersSymbol]?: Parameters;
-};
-export type LocalizationKey<Parameters = void> = string | ProxyLocalizationKey<Parameters>;
-export type EnumLocalizationKey<T extends Enumeration = Enumeration, Parameters = void> = Parameters extends void ? {
-    enum: T;
-    value?: EnumerationValue<T>;
-    parameters?: void;
-} : {
-    enum: T;
-    value?: EnumerationValue<T>;
-    parameters: Parameters;
-};
-export type LocalizationData<Parameters = any, E extends Enumeration = any> = LocalizationKey | EnumLocalizationKey<E, Parameters> | LocalizationDataObject<Parameters> | {
-    key: LocalizationKey;
-    parameters?: void;
-};
-export type LocalizationDataObject<Parameters> = {
-    key: LocalizationKey<Parameters>;
-    parameters: Parameters;
-};
-export type ProxyLocalizationKeys<T extends LocalizationTemplate> = {
-    [P in keyof T]: T[P] extends LocalizationTemplate ? ProxyLocalizationKeys<T[P]> : T[P] extends LocalizeItem<infer R> ? ProxyLocalizationKey<R> : ProxyLocalizationKey;
-};
-export declare function getProxyLocalizationKey<Parameters = void>(key: string): ProxyLocalizationKey<Parameters>;
-export declare function isProxyLocalizationKey(value: any): value is ProxyLocalizationKey;
-export declare function isEnumLocalizationKey(key: any): key is EnumLocalizationKey;
-export declare function isLocalizationDataObject(value: LocalizationData): value is LocalizationDataObject<any>;
-/** helper function to ensure type safety */
-export declare function localizationData<T>(key: LocalizationKey<T>, parameters: T): LocalizationDataObject<T>;
-export declare function localizationData<T>(data: LocalizationData<T>): LocalizationDataObject<T>;
-/**
- * returns a Proxy which simply returns the key you accessed. Can be used to have typesafe localizations (in templates and the API) by not relying on plain strings
- * @param localization
- * @returns
- */
-export declare function getLocalizationKeys<T extends Localization>(_localization?: T): ProxyLocalizationKeys<T['keys']>;
-export declare const autoEnumerationLocalization: typeof _autoEnumerationLocalization;
-export declare class LocalizationService {
-    #private;
-    readonly activeLanguage: Signal<Language | null>;
-    readonly availableLanguages: Signal<Language[]>;
-    readonly activeLanguage$: Observable<Language | null>;
-    readonly availableLanguages$: Observable<Language[]>;
-    constructor(logger: Logger);
-    registerLocalization(...localizations: Localization[]): void;
-    hasLanguage(languageCode: string): boolean;
-    getLanguage(languageCode: string): Language;
-    setLanguage(languageOrCode: Language | string): void;
-    setLocalization(localization: Localization): void;
-    tryGetItem<Parameters>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): LocalizeItem | undefined;
-    hasKey<Parameters>(key: LocalizationKey<Parameters> | LocalizationData<Parameters>): boolean;
-    localizeOnce<Parameters = void>(keyOrData: LocalizationKey<Parameters> | LocalizationData<Parameters>): string;
-    localizeEnumOnce<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): string;
-    localize<Parameters>(data: LocalizationData<Parameters>): Signal<string>;
-    localizeEnum<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Signal<string>;
-    localize$<Parameters>(data: LocalizationData<Parameters>): Observable<string>;
-    localizeEnum$<T extends Enumeration>(enumeration: T, value?: EnumerationValue<T>, parameters?: unknown): Observable<string>;
-    private localizeItem;
-}
-export declare function enumerationLocalization<T extends Enumeration>(enumeration: T, name: LocalizeItem | undefined, localization: EnumerationLocalization<T>): EnumerationLocalizationEntry<T>;
-export declare function enumerationLocalization<T extends Enumeration>(enumeration: T, localization: EnumerationLocalization<T>): EnumerationLocalizationEntry<T>;
-declare function _autoEnumerationLocalization<T extends Enumeration>(enumeration: T, name?: LocalizeItem): EnumerationLocalizationEntry<T>;
-export declare function isLocalizeItem(value: any): value is LocalizeItem<any>;
-export {};

package/theme/adapters/tailwind-adapter.d.ts

@@ -1,18 +0,0 @@
-import type { Theme } from '../../theme/theme-service.js';
-export type TailwindPalette = {
-    DEFAULT: string;
-    50: string;
-    100: string;
-    200: string;
-    300: string;
-    400: string;
-    500: string;
-    600: string;
-    700: string;
-    800: string;
-    900: string;
-    950: string;
-};
-export declare function generateTailwindColorsFromTheme(theme: Theme, tailwindNamePrefix?: string): Record<string, TailwindPalette>;
-export declare function generateTailwindColorsFromThemeColors(colors: readonly string[], tailwindNamePrefix?: string): Record<string, TailwindPalette>;
-export declare function generateTailwindPalette(color: string): TailwindPalette;

package/theme/theme-service.d.ts

@@ -1,43 +0,0 @@
-import { type Observable } from 'rxjs';
-export type CalculatedPalette<Colors extends string = string> = {
-    [Color in Colors]: ColorTonesWithRgb;
-};
-export type CalculatedTheme<Colors extends string = string> = {
-    palette: CalculatedPalette<Colors>;
-};
-export type Theme<Colors extends string = string> = {
-    palette: Palette<Colors>;
-};
-export type Palette<Colors extends string = string> = {
-    [Color in Colors]: string | ColorTones;
-};
-export type ColorTones = {
-    base: string;
-    50: string;
-    100: string;
-    200: string;
-    300: string;
-    400: string;
-    500: string;
-    600: string;
-    700: string;
-    800: string;
-    900: string;
-};
-export type ColorTonesWithRgb = ColorTones & {
-    [Tone in keyof ColorTones as `${Tone}Rgb`]: string;
-};
-export declare const themeColorTones: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900];
-export declare const DEFAULT_THEME: import("../injector/token.js").InjectionToken<Theme<string>, never>;
-export declare class ThemeService<Colors extends string = string> {
-    private readonly themeSubject;
-    private readonly calculatedThemeSubject;
-    private readonly defaultTheme;
-    readonly colors: Colors[];
-    readonly theme$: Observable<Theme<Colors>>;
-    readonly calculatedTheme$: Observable<CalculatedTheme<Colors>>;
-    get theme(): Theme<Colors>;
-    get calculatedTheme(): CalculatedTheme<Colors>;
-    constructor(defaultTheme: Theme<Colors>);
-    setTheme(theme?: Theme<Colors> | undefined): void;
-}

package/threading/thread-pool.d.ts

@@ -1,20 +0,0 @@
-import type * as NodeWorkerThreads from 'node:worker_threads';
-import type { LiteralUnion } from 'type-fest';
-import type { AsyncDisposable } from '../disposable/index.js';
-import { disposeAsync } from '../disposable/index.js';
-import type { Logger } from '../logger/index.js';
-import type { ThreadWorker } from './thread-worker.js';
-export type ThreadOptions = (WorkerOptions | NodeWorkerThreads.WorkerOptions) & {
-    threadCount?: number;
-};
-export declare class ThreadPool implements AsyncDisposable {
-    private readonly pool;
-    readonly url: string | URL;
-    readonly options: ThreadOptions | undefined;
-    constructor(url: string | URL, logger: Logger, options?: ThreadOptions);
-    dispose(): Promise<void>;
-    [disposeAsync](): Promise<void>;
-    getProcessor<T extends ThreadWorker>(name?: string): (...args: Parameters<T>) => Promise<ReturnType<T>>;
-    process<T extends ThreadWorker>(name: LiteralUnion<'default', string>, ...args: Parameters<T>): Promise<ReturnType<T>>;
-    private spawn;
-}

package/types/geo-json.d.ts

@@ -1,36 +0,0 @@
-import type { JsonObject } from '../types.js';
-export type Position = [longitude: number, latitude: number, elevation?: number];
-export type GeoJsonObject<Type extends string> = {
-    type: Type;
-    bbox?: [number, number, number, number] | [number, number, number, number, number, number];
-};
-export type Point = GeoJsonObject<'Point'> & {
-    coordinates: Position;
-};
-export type LineString = GeoJsonObject<'LineString'> & {
-    coordinates: Position[];
-};
-export type Polygon = GeoJsonObject<'Polygon'> & {
-    coordinates: Position[][];
-};
-export type MultiPoint = GeoJsonObject<'MultiPoint'> & {
-    coordinates: Position[];
-};
-export type MultiLineString = GeoJsonObject<'MultiLineString'> & {
-    coordinates: Position[][];
-};
-export type MultiPolygon = GeoJsonObject<'MultiPolygon'> & {
-    coordinates: Position[][][];
-};
-export type GeometryCollection = GeoJsonObject<'GeometryCollection'> & {
-    geometries: Geometry[];
-};
-export type Geometry = Point | LineString | Polygon | MultiPoint | MultiLineString | MultiPolygon | GeometryCollection;
-export type Feature<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'Feature'> & {
-    id?: string | number;
-    geometry: G;
-    properties: P;
-};
-export type FeatureCollection<G extends Geometry | null = null, P extends JsonObject | null = null> = GeoJsonObject<'FeatureCollection'> & {
-    features: Feature<G, P>[];
-};

package/types/tagged.d.ts

@@ -1,16 +0,0 @@
-import type { Record } from '../types.js';
-export declare const tag: unique symbol;
-export declare const type: unique symbol;
-export type TagContainer<Type, Token> = {
-    readonly [tag]?: Token;
-    readonly [type]?: Type;
-};
-export type Tag<Type, Token extends PropertyKey, TagMetadata> = TagContainer<Type, Record<Token, TagMetadata>>;
-export type HasTag<T, Token = unknown> = T extends TagContainer<unknown, Token> ? true : false;
-export type Tagged<Type = unknown, TagName extends PropertyKey = PropertyKey, TagMetadata = unknown> = Type & Tag<Type, TagName, TagMetadata>;
-export type GetTagMetadata<Type extends Tag<unknown, TagName, unknown>, TagName extends PropertyKey> = NonNullable<Type[typeof tag]>[TagName];
-export type UnwrapTagged<TaggedType extends Tag<unknown, PropertyKey, any>> = TaggedType extends Tagged<infer Type, PropertyKey, any> ? Type : never;
-export type Untagged<T> = T extends Tagged ? UnwrapTagged<T> : T;
-export type UntaggedDeep<T> = Untagged<T> extends any[] | Record ? {
-    [P in keyof Untagged<T>]: UntaggedDeep<Untagged<T>[P]>;
-} : Untagged<T>;