@valbuild/core 0.72.4 → 0.73.1

package/dist/declarations/src/index.d.ts

@@ -7,14 +7,15 @@ export type { FileMetadata } from "./schema/file.js";
 export type { ValModule, SerializedModule, InferValModuleType } from "./module.js";
 export type { SourceObject, SourcePrimitive, Source } from "./source/index.js";
 export type { FileSource } from "./source/file.js";
+export type { RemoteSource, RemoteRef } from "./source/remote.js";
+export { DEFAULT_VAL_REMOTE_HOST } from "./schema/remote.js";
 export type { RawString } from "./schema/string.js";
 export type { ImageSource } from "./source/image.js";
-export type { AllRichTextOptions, Bold, Styles, HeadingNode, ImageNode, Italic, LineThrough, ListItemNode, LinkNode, OrderedListNode, ParagraphNode, BrNode, RichTextNode, RichTextOptions, RichTextSource, BlockNode, SpanNode, UnorderedListNode, } from "./source/richtext.js";
+export type { AllRichTextOptions, Bold, Styles, HeadingNode, ImageNode, Italic, LineThrough, ListItemNode, LinkNode, OrderedListNode, ParagraphNode, BrNode, RichTextNode, RichTextOptions, SerializedRichTextOptions, RichTextSource, BlockNode, SpanNode, UnorderedListNode, } from "./source/richtext.js";
 export { type Val, type SerializedVal, type ModuleFilePath, type PatchId, type ModulePath, type SourcePath, type JsonOfSource, type ParentPatchId, } from "./val/index.js";
 export type { Json, JsonPrimitive, JsonArray, JsonObject } from "./Json.js";
 export type { ValidationError, ValidationErrors, } from "./schema/validation/ValidationError.js";
 export type { ValidationFix } from "./schema/validation/ValidationFix.js";
-export * as expr from "./expr/index.js";
 export { FILE_REF_PROP, FILE_REF_SUBTYPE_TAG } from "./source/file.js";
 export { VAL_EXTENSION, type SourceArray } from "./source/index.js";
 export { derefPatch } from "./patch/deref.js";
@@ -26,12 +27,17 @@ import { getSchema } from "./selector/index.js";
 import { ModulePath, getValPath, isVal } from "./val/index.js";
 import { convertFileSource } from "./schema/file.js";
 import { createValPathOfItem } from "./selector/SelectorProxy.js";
-import { getVal } from "./future/fetchVal.js";
 import { Operation } from "./patch/index.js";
 import { initSchema } from "./initSchema.js";
 import { getMimeType, mimeTypeToFileExt, filenameToMimeType } from "./mimeType/index.js";
 import { type ImageMetadata } from "./schema/image.js";
 import { type FileMetadata } from "./schema/file.js";
+import { isFile } from "./source/file.js";
+import { createRemoteRef } from "./source/remote.js";
+import { getValidationBasis, getValidationHash } from "./remote/validationBasis.js";
+import { getFileHash, hashToRemoteFileHash } from "./remote/fileHash.js";
+import { splitRemoteRef } from "./remote/splitRemoteRef.js";
+import { convertRemoteSource } from "./schema/remote.js";
 export { type SerializedArraySchema, ArraySchema } from "./schema/array.js";
 export { type SerializedObjectSchema, ObjectSchema } from "./schema/object.js";
 export { type SerializedRecordSchema, RecordSchema } from "./schema/record.js";
@@ -53,14 +59,23 @@ declare const Internal: {
         core: string | null;
     };
     convertFileSource: typeof convertFileSource;
+    convertRemoteSource: typeof convertRemoteSource;
     getSchema: typeof getSchema;
     getValPath: typeof getValPath;
-    getVal: typeof getVal;
     getSource: typeof getSource;
     resolvePath: typeof resolvePath;
     splitModuleFilePathAndModulePath: typeof splitModuleFilePathAndModulePath;
     joinModuleFilePathAndModulePath: typeof joinModuleFilePathAndModulePath;
+    remote: {
+        createRemoteRef: typeof createRemoteRef;
+        getValidationBasis: typeof getValidationBasis;
+        getValidationHash: typeof getValidationHash;
+        getFileHash: typeof getFileHash;
+        hashToRemoteFileHash: typeof hashToRemoteFileHash;
+        splitRemoteRef: typeof splitRemoteRef;
+    };
     isVal: typeof isVal;
+    isFile: typeof isFile;
     createValPathOfItem: typeof createValPathOfItem;
     getSHA256Hash: (bits: Uint8Array) => string;
     initSchema: typeof initSchema;
@@ -78,6 +93,7 @@ declare const Internal: {
         path: string[];
         filePath: string;
         value: string;
+        remote: boolean;
     };
     createPatchJSONPath: (modulePath: ModulePath) => string;
     createPatchPath: (modulePath: ModulePath) => string[];

package/dist/declarations/src/initSchema.d.ts

@@ -92,13 +92,13 @@ export declare function initSchema(): {
         }>;
         inline: Partial<{
             a: boolean;
-            img: boolean;
+            img: boolean | import("./schema/image.js").ImageSchema<import("./index.js").ImageSource | import("./index.js").RemoteSource<import("./schema/image.js").ImageMetadata>>;
         }>;
     }>>(options?: O | undefined) => import("./schema/richtext.js").RichTextSchema<O, import("./index.js").RichTextSource<O>>;
-    image: (options?: import("./schema/image.js").ImageOptions | undefined) => import("./schema/index.js").Schema<import("./index.js").ImageSource>;
+    image: (options?: import("./schema/image.js").ImageOptions | undefined) => import("./schema/image.js").ImageSchema<import("./index.js").ImageSource>;
     literal: <T_2 extends string>(value: T_2) => import("./schema/literal.js").LiteralSchema<T_2>;
     keyOf: <Src extends import("./selector/index.js").GenericSelector<import("./source/index.js").SourceObject, undefined> & import("./module.js").ValModuleBrand>(valModule: Src) => import("./schema/index.js").Schema<Src extends import("./selector/index.js").GenericSelector<infer S_2 extends import("./source/index.js").Source, undefined> ? S_2 extends readonly import("./source/index.js").Source[] ? number : S_2 extends import("./source/index.js").SourceObject ? string extends keyof S_2 ? import("./schema/string.js").RawString : keyof S_2 : S_2 extends Record<string, import("./source/index.js").Source> ? import("./schema/string.js").RawString : never : never>;
     record: <S_3 extends import("./schema/index.js").Schema<import("./selector/index.js").SelectorSource>>(schema: S_3) => import("./schema/index.js").Schema<Record<string, import("./schema/index.js").SelectorOfSchema<S_3>>>;
-    file: (options?: import("./schema/file.js").FileOptions | undefined) => import("./schema/index.js").Schema<import("./index.js").FileSource<import("./schema/file.js").FileMetadata>>;
+    file: (options?: import("./schema/file.js").FileOptions | undefined) => import("./schema/file.js").FileSchema<import("./index.js").FileSource<import("./schema/file.js").FileMetadata>>;
     date: (options?: Record<string, never> | undefined) => import("./schema/date.js").DateSchema<import("./schema/string.js").RawString>;
 };

package/dist/declarations/src/initVal.d.ts

@@ -3,15 +3,17 @@ import { InitSchema } from "./initSchema.js";
 import { getValPath as getPath } from "./val/index.js";
 import { initFile } from "./source/file.js";
 import { initImage } from "./source/image.js";
+import { initRemote } from "./source/remote.js";
 export type ContentConstructor = {
     define: typeof define;
     file: ReturnType<typeof initFile>;
     image: ReturnType<typeof initImage>;
+    remote: ReturnType<typeof initRemote>;
 };
 export type ValConstructor = {
     unstable_getPath: typeof getPath;
 };
-export type ConfigDirectory = `/public/${string}`;
+export type ConfigDirectory = `/public/val`;
 export type ValConfig = {
     project?: string;
     root?: string;

package/dist/declarations/src/patch/index.d.ts

@@ -1,6 +1,6 @@
 export { JSONOps } from "./json.js";
 export { type OperationJSON, type Operation } from "./operation.js";
 export { parsePatch, parseJSONPointer, formatJSONPointer } from "./parse.js";
-export { type JSONValue, type Ops, PatchError } from "./ops.js";
+export { type JSONValue, type Ops, PatchError, type ReadonlyJSONValue, } from "./ops.js";
 export { type PatchJSON, type Patch, applyPatch, type PatchBlock, type ParentRef, } from "./patch.js";
 export { isNotRoot, deepEqual, deepClone, parseAndValidateArrayIndex, sourceToPatchPath, } from "./util.js";

package/dist/declarations/src/patch/operation.d.ts

@@ -31,6 +31,7 @@ export type OperationJSON = {
     path: string;
     filePath: string;
     value: JSONValue;
+    remote: boolean;
 };
 /**
  * Parsed form of JSON patch operation.
@@ -70,4 +71,6 @@ export type Operation = {
     /** files can be nested within an object (for richtext), in order to find the actual file element this path can be used (we use this to add the patch_id on files) */
     nestedFilePath?: string[];
     value: JSONValue;
+    /** true if this is a remote file */
+    remote: boolean;
 };

package/dist/declarations/src/remote/fileHash.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from "buffer";
+export declare function hashToRemoteFileHash(hash: string): string;
+export declare function getFileHash(text: Buffer): string;

package/dist/declarations/src/remote/splitRemoteRef.d.ts

@@ -0,0 +1,13 @@
+export declare function splitRemoteRef(ref: string): {
+    status: "success";
+    remoteHost: string;
+    bucket: string;
+    projectId: string;
+    version: string;
+    validationHash: string;
+    fileHash: string;
+    filePath: `public/val/${string}`;
+} | {
+    status: "error";
+    error: string;
+};

package/dist/declarations/src/remote/validationBasis.d.ts

@@ -0,0 +1,13 @@
+import { SerializedFileSchema } from "../schema/file.js";
+import { SerializedImageSchema } from "../schema/image.js";
+/**
+ * The validation basis is used in remote refs to determine if the remote content needs to be re-validated.
+ *
+ * If the validation basis changes, we need to re-validate the remote content.
+ *
+ * NOTE: We do not care if the file path is different as long as the extension is the same.
+ *       This way we can rename a file, without having to re-validate it.
+ *       The version is outside of the validation hash, so that it is possible to manually fix the version without having to re-validate.
+ */
+export declare function getValidationBasis(coreVersion: string, schema: SerializedImageSchema | SerializedFileSchema, fileExt: string, metadata: Record<string, unknown> | undefined, fileHash: string): string;
+export declare function getValidationHash(coreVersion: string, schema: SerializedImageSchema | SerializedFileSchema, fileExt: string, metadata: Record<string, unknown> | undefined, fileHash: string, textEncoder: TextEncoder): string;

package/dist/declarations/src/schema/file.d.ts

@@ -3,27 +3,31 @@ import { FileSource } from "../source/file.js";
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
+import { RemoteSource } from "../index.js";
 export type FileOptions = {
     accept?: string;
 };
 export type SerializedFileSchema = {
     type: "file";
     options?: FileOptions;
+    remote?: boolean;
     opt: boolean;
 };
 export type FileMetadata = {
     mimeType?: string;
 };
-export declare class FileSchema<Src extends FileSource<FileMetadata | undefined> | null> extends Schema<Src> {
+export declare class FileSchema<Src extends FileSource<FileMetadata | undefined> | RemoteSource<FileMetadata | undefined> | null> extends Schema<Src> {
     readonly options?: FileOptions | undefined;
     readonly opt: boolean;
-    constructor(options?: FileOptions | undefined, opt?: boolean);
+    protected readonly isRemote: boolean;
+    constructor(options?: FileOptions | undefined, opt?: boolean, isRemote?: boolean);
+    remote(): FileSchema<Src | RemoteSource<FileMetadata | undefined>>;
     validate(path: SourcePath, src: Src): ValidationErrors;
     assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
-export declare const file: (options?: FileOptions) => Schema<FileSource<FileMetadata>>;
+export declare const file: (options?: FileOptions) => FileSchema<FileSource<FileMetadata>>;
 export declare function convertFileSource<Metadata extends {
     readonly [key: string]: Json;
 } | undefined = {

package/dist/declarations/src/schema/image.d.ts

@@ -3,6 +3,7 @@ import { FileSource } from "../source/file.js";
 import { ImageSource } from "../source/image.js";
 import { SourcePath } from "../val/index.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
+import { RemoteSource } from "../source/remote.js";
 export type ImageOptions = {
     ext?: ["jpg"] | ["webp"];
     directory?: string;
@@ -13,6 +14,7 @@ export type SerializedImageSchema = {
     type: "image";
     options?: ImageOptions;
     opt: boolean;
+    remote?: boolean;
 };
 export type ImageMetadata = {
     width: number;
@@ -24,13 +26,15 @@ export type ImageMetadata = {
         y: number;
     };
 };
-export declare class ImageSchema<Src extends FileSource<ImageMetadata | undefined> | null> extends Schema<Src> {
+export declare class ImageSchema<Src extends FileSource<ImageMetadata | undefined> | RemoteSource<ImageMetadata | undefined> | null> extends Schema<Src> {
     readonly options?: ImageOptions | undefined;
     readonly opt: boolean;
-    constructor(options?: ImageOptions | undefined, opt?: boolean);
+    protected readonly isRemote: boolean;
+    constructor(options?: ImageOptions | undefined, opt?: boolean, isRemote?: boolean);
+    remote(): ImageSchema<Src | RemoteSource<ImageMetadata | undefined>>;
     validate(path: SourcePath, src: Src): ValidationErrors;
     assert(path: SourcePath, src: unknown): SchemaAssertResult<Src>;
     nullable(): Schema<Src | null>;
     serialize(): SerializedSchema;
 }
-export declare const image: (options?: ImageOptions) => Schema<ImageSource>;
+export declare const image: (options?: ImageOptions) => ImageSchema<ImageSource>;

package/dist/declarations/src/schema/remote.d.ts

@@ -0,0 +1,11 @@
+import { Json } from "../index.js";
+import { RemoteSource } from "../source/remote.js";
+export declare const DEFAULT_VAL_REMOTE_HOST = "https://remote.val.build";
+export declare function convertRemoteSource<Metadata extends {
+    readonly [key: string]: Json;
+} | undefined = {
+    readonly [key: string]: Json;
+} | undefined>(src: RemoteSource<Metadata>): {
+    url: string;
+    metadata?: Metadata;
+};

package/dist/declarations/src/schema/richtext.d.ts

@@ -1,6 +1,8 @@
 import { Schema, SchemaAssertResult, SerializedSchema } from "./index.js";
-import { RichTextSource, RichTextOptions } from "../source/richtext.js";
+import { ImageSource } from "../source/image.js";
+import { RichTextSource, RichTextOptions, SerializedRichTextOptions } from "../source/richtext.js";
 import { SourcePath } from "../val/index.js";
+import { ImageSchema } from "./image.js";
 import { ValidationErrors } from "./validation/ValidationError.js";
 type ValidationOptions = {
     maxLength?: number;
@@ -9,7 +11,7 @@ type ValidationOptions = {
 export type SerializedRichTextSchema = {
     type: "richtext";
     opt: boolean;
-    options?: RichTextOptions & ValidationOptions;
+    options?: SerializedRichTextOptions & ValidationOptions;
 };
 export declare class RichTextSchema<O extends RichTextOptions, Src extends RichTextSource<O> | null> extends Schema<Src> {
     readonly options: O & ValidationOptions;
@@ -42,7 +44,7 @@ export declare const richtext: <O extends Partial<{
     }>;
     inline: Partial<{
         a: boolean;
-        img: boolean;
+        img: boolean | ImageSchema<ImageSource | import("../index.js").RemoteSource<import("./image.js").ImageMetadata>>;
     }>;
 }>>(options?: O | undefined) => RichTextSchema<O, RichTextSource<O>>;
 export {};

package/dist/declarations/src/schema/validation/ValidationFix.d.ts

@@ -1,2 +1,2 @@
-export declare const ValidationFix: readonly ["image:change-extension", "image:add-metadata", "image:check-metadata", "file:change-extension", "file:add-metadata", "file:check-metadata", "keyof:check-keys"];
+export declare const ValidationFix: readonly ["image:change-extension", "image:add-metadata", "image:check-metadata", "image:upload-remote", "image:download-remote", "image:check-remote", "file:change-extension", "file:add-metadata", "file:check-metadata", "file:upload-remote", "file:download-remote", "file:check-remote", "keyof:check-keys"];
 export type ValidationFix = (typeof ValidationFix)[number];

package/dist/declarations/src/selector/index.d.ts

@@ -14,10 +14,11 @@ import { AllRichTextOptions, RichTextSource } from "../source/richtext.js";
 import { ImageSelector } from "./image.js";
 import { RichTextSelector } from "./richtext.js";
 import { ImageSource } from "../source/image.js";
+import { RemoteSource } from "../source/remote.js";
 export type Selector<T extends Source> = Source extends T ? GenericSelector<T> : T extends ImageSource ? ImageSelector : T extends FileSource<infer M> ? FileSelector<M> : T extends RichTextSource<infer O> ? RichTextSelector<O> : T extends SourceObject ? ObjectSelector<T> : T extends SourceArray ? ArraySelector<T> : T extends string ? StringSelector<T> : T extends number ? NumberSelector<T> : T extends boolean ? BooleanSelector<T> : T extends null ? PrimitiveSelector<null> : never;
 export type SelectorSource = SourcePrimitive | undefined | readonly SelectorSource[] | {
     [key: string]: SelectorSource;
-} | FileSource | RichTextSource<AllRichTextOptions> | GenericSelector<Source>;
+} | FileSource | RemoteSource | RichTextSource<AllRichTextOptions> | GenericSelector<Source>;
 /**
  * @internal
  */

package/dist/declarations/src/source/file.d.ts

@@ -4,7 +4,7 @@ import { Json } from "../Json.js";
 export declare const FILE_REF_PROP: "_ref";
 export declare const FILE_REF_SUBTYPE_TAG: "_tag";
 export type FileMetadata = {
-    readonly [key: string]: Json;
+    mimeType?: string;
 };
 /**
  * A file source represents the path to a (local) file.
@@ -22,7 +22,7 @@ export type FileSource<Metadata extends FileMetadata | undefined = FileMetadata
 export declare const initFile: (config?: ValConfig) => {
     <Metadata extends {
         readonly [key: string]: Json;
-    }>(ref: `/public/${string}/${string}`, metadata: Metadata): FileSource<Metadata>;
-    (ref: `/public/${string}/${string}`, metadata?: undefined): FileSource<undefined>;
+    }>(ref: `/public/val/${string}`, metadata: Metadata): FileSource<Metadata>;
+    (ref: `/public/val/${string}`, metadata?: undefined): FileSource<undefined>;
 };
 export declare function isFile(obj: unknown): obj is FileSource;

package/dist/declarations/src/source/image.d.ts

@@ -14,6 +14,6 @@ export type ImageSource<Metadata extends ImageMetadata | undefined = ImageMetada
     readonly patch_id?: string;
 };
 export declare const initImage: (config?: ValConfig) => {
-    (ref: `/public/${string}/${string}`, metadata: ImageMetadata): ImageSource<ImageMetadata>;
-    (ref: `/public/${string}/${string}`, metadata?: undefined): ImageSource<undefined>;
+    (ref: `/public/val/${string}`, metadata: ImageMetadata): ImageSource<ImageMetadata>;
+    (ref: `/public/val/${string}`, metadata?: undefined): ImageSource<undefined>;
 };

package/dist/declarations/src/source/index.d.ts

@@ -1,8 +1,7 @@
 import { FileSource } from "./file.js";
-import { I18nSource, I18nCompatibleSource } from "./future/i18n.js";
-import { RemoteSource, RemoteCompatibleSource } from "./future/remote.js";
+import { RemoteSource } from "./remote.js";
 import { RichTextOptions, RichTextSource } from "./richtext.js";
-export type Source = SourcePrimitive | SourceObject | SourceArray | I18nSource<string[], I18nCompatibleSource> | RemoteSource<RemoteCompatibleSource> | FileSource | RichTextSource<RichTextOptions>;
+export type Source = SourcePrimitive | SourceObject | SourceArray | RemoteSource | FileSource | RichTextSource<RichTextOptions>;
 export type SourceObject = {
     [key in string]: Source;
 } & {
@@ -24,7 +23,7 @@ export type SourceObject = {
 export type SourceArray = readonly Source[];
 export type SourcePrimitive = string | number | boolean | null;
 export declare const VAL_EXTENSION: "_type";
-export declare function getValExtension(source: Source): false | "" | 0 | "file" | "remote" | "i18n" | null | undefined;
+export declare function getValExtension(source: Source): false | "" | 0 | "file" | "remote" | null | undefined;
 /**
  * A phantom type parameter is one that doesn't show up at runtime, but is checked statically (and only) at compile time.
  *

package/dist/declarations/src/source/remote.d.ts

@@ -0,0 +1,23 @@
+import { VAL_EXTENSION } from "./index.js";
+import { ValConfig } from "../initVal.js";
+import { ImageMetadata } from "../schema/image.js";
+import { FILE_REF_PROP, FileMetadata } from "./file.js";
+/**
+ * A remote source represents data that is not stored locally.
+ */
+export type RemoteSource<Metadata extends FileMetadata | undefined = FileMetadata | undefined> = {
+    readonly [FILE_REF_PROP]: string;
+    readonly [VAL_EXTENSION]: "remote";
+    readonly metadata?: Metadata;
+    readonly patch_id?: string;
+};
+export declare const initRemote: (config?: ValConfig) => <Metadata extends ImageMetadata | FileMetadata>(ref: RemoteRef, metadata: Metadata) => RemoteSource<Metadata>;
+export type RemoteRef = `${string}/file/p/${string}/v/${string}/h/${string}/f/${string}/p/public/val/${string}`;
+export declare function createRemoteRef(remoteHost: string, { publicProjectId, coreVersion, validationHash, fileHash, filePath, bucket, }: {
+    publicProjectId: string;
+    coreVersion: string;
+    validationHash: string;
+    fileHash: string;
+    filePath: `public/val/${string}`;
+    bucket: string;
+}): RemoteRef;

package/dist/declarations/src/source/richtext.d.ts

@@ -1,4 +1,7 @@
+import { ImageMetadata, ImageSchema, SerializedImageSchema } from "../schema/image.js";
+import { FileSource } from "./file.js";
 import { ImageSource } from "./image.js";
+import { RemoteSource } from "./remote.js";
 export type RichTextOptions = Partial<{
     style: Partial<{
         bold: boolean;
@@ -17,7 +20,28 @@ export type RichTextOptions = Partial<{
     }>;
     inline: Partial<{
         a: boolean;
-        img: boolean;
+        img: boolean | ImageSchema<ImageSource | RemoteSource<ImageMetadata>>;
+    }>;
+}>;
+export type SerializedRichTextOptions = Partial<{
+    style: Partial<{
+        bold: boolean;
+        italic: boolean;
+        lineThrough: boolean;
+    }>;
+    block: Partial<{
+        h1: boolean;
+        h2: boolean;
+        h3: boolean;
+        h4: boolean;
+        h5: boolean;
+        h6: boolean;
+        ul: boolean;
+        ol: boolean;
+    }>;
+    inline: Partial<{
+        a: boolean;
+        img: boolean | SerializedImageSchema;
     }>;
 }>;
 export type AllRichTextOptions = {
@@ -66,8 +90,11 @@ export type SpanNode<O extends RichTextOptions> = {
 };
 export type ImageNode<O extends RichTextOptions> = NonNullable<O["inline"]>["img"] extends true ? {
     tag: "img";
-    src: ImageSource;
-} : never;
+    src: ImageSource | RemoteSource<ImageMetadata>;
+} : NonNullable<O["inline"]>["img"] extends ImageSchema<infer Src> ? Src extends RemoteSource | FileSource ? {
+    tag: "img";
+    src: Src;
+} : never : never;
 type LinkTagNode<O extends RichTextOptions> = {
     tag: "a";
     href: string;

package/dist/declarations/src/val/index.d.ts

@@ -4,15 +4,16 @@ import { Val as ArrayVal } from "./array.js";
 import { Val as PrimitiveVal } from "./primitive.js";
 import { Json, JsonArray, JsonObject, JsonPrimitive } from "../Json.js";
 import { Path, Selector } from "../selector/index.js";
-import { I18nSource } from "../source/future/i18n.js";
-import { RemoteSource } from "../source/future/remote.js";
+import { RemoteSource } from "../source/remote.js";
 import { FileSource } from "../source/file.js";
 export type SerializedVal = {
     val: SerializedVal | Json;
     valPath: SourcePath | undefined;
 };
 export declare function isSerializedVal(val: unknown): val is SerializedVal;
-export type JsonOfSource<T extends Source> = Json extends T ? Json : T extends I18nSource<readonly string[], infer U> ? JsonOfSource<U> : T extends RemoteSource<infer U> ? JsonOfSource<U> : T extends FileSource ? {
+export type JsonOfSource<T extends Source> = Json extends T ? Json : T extends RemoteSource ? {
+    url: string;
+} : T extends FileSource ? {
     url: string;
 } : T extends SourceObject ? {
     [key in keyof T]: JsonOfSource<T[key]>;