@polyipseity/obsidian-plugin-library/dist/src/types.d.ts

Library for Obsidian plugins.

import type { DeepReadonly, DeepWritable, Opaque, WithOpaque } from "ts-essentials";
import type { LibraryUUIDs } from "./magic.js";
export type AnyObject = Readonly<Record<keyof any, unknown>>;
export interface AsyncFunctionConstructor {
    <const A extends readonly string[]>(...args: A): (this: unknown, ...args: A extends readonly [...infer B, unknown] ? {
        readonly [I in keyof B]: unknown;
    } : []) => Promise<unknown>;
    new <const A extends readonly string[]>(...args: A): (this: unknown, ...args: A extends readonly [...infer B, unknown] ? {
        readonly [I in keyof B]: unknown;
    } : []) => Promise<unknown>;
}
export type Base64String = Opaque<string, typeof LibraryUUIDs["UUID3"]>;
export type CodePoint = Opaque<string, typeof LibraryUUIDs["UUID0"]> & {
    readonly codePointAt: (pos: 0) => number;
};
export type Deopaque<T> = T extends WithOpaque<infer U> ? T extends Opaque<infer V, U> ? V : never : never;
export type DistributeKeys<T> = T extends unknown ? keyof T : never;
export type DistributeValues<T, K> = T extends unknown ? K extends keyof T ? T[K] : never : never;
export type Evaluate<T> = T extends (...args: infer A) => infer R ? (...args: A) => R : T extends object ? T extends infer O ? {
    [K in keyof O]: O[K];
} : never : T;
export type IsExact<T, U> = (<G>() => G extends T ? 1 : -1) extends (<G>() => G extends U ? 1 : -1) ? true : false;
export type ReadonlyTuple<Type = unknown> = readonly [] | readonly [Type, ...Type[]];
export type SemVerString = Opaque<string, typeof LibraryUUIDs["UUID1"]>;
export type Unchecked<T> = {
    readonly [_ in keyof T]?: unknown;
};
export declare const NULL_SEM_VER_STRING: string & WithOpaque<"fec54e0c-8342-4418-bc4b-57ea4d92c3d4">;
export declare function contravariant<T>(value: readonly T[]): readonly T[];
export declare function correctType(value: Window): Window & typeof globalThis;
export declare function deopaque<T>(value: T): Deopaque<T>;
export declare function launderUnchecked<T extends object>(value: unknown): Unchecked<T>;
export declare function opaqueOrDefault<T, I extends string, D>(type: (value: T) => Opaque<T, I>, value: T, defaultValue: D): D | Opaque<T, I>;
export declare function codePoint(value: string): CodePoint;
export declare function semVerString(value: string): SemVerString;
export declare function simplifyType<T>(value: DeepWritable<DeepReadonly<T>> | DeepWritable<DeepWritable<T>>): DeepWritable<T>;
export declare function simplifyType<T>(value: DeepReadonly<DeepReadonly<T>> | DeepReadonly<DeepWritable<T>>): DeepReadonly<T>;
//# sourceMappingURL=types.d.ts.map