@platforma-sdk/block-tools 2.1.5 → 2.1.7

package/dist/lib.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lib.d.ts","sourceRoot":"","sources":["../src/lib.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,UAAU,MAAM,eAAe,CAAC;AAC5C,cAAc,MAAM,CAAC"}

package/dist/registry_v1/config.d.ts

@@ -0,0 +1,12 @@
+import { PlRegFullPackageConfigData, PlRegPackageConfigDataShard } from './config_schema';
+import { BlockRegistry } from './registry';
+import { FullBlockPackageName } from './v1_repo_schema';
+import { MiLogger } from '@milaboratories/ts-helpers';
+export declare class PlRegPackageConfig {
+    readonly conf: PlRegFullPackageConfigData;
+    constructor(conf: PlRegFullPackageConfigData);
+    createRegistry(logger?: MiLogger): BlockRegistry;
+    get fullPackageName(): FullBlockPackageName;
+}
+export declare function getConfig(finalShard: PlRegPackageConfigDataShard): Promise<PlRegPackageConfig>;
+//# sourceMappingURL=config.d.ts.map

package/dist/registry_v1/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/registry_v1/config.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAkDtD,qBAAa,kBAAkB;aACD,IAAI,EAAE,0BAA0B;gBAAhC,IAAI,EAAE,0BAA0B;IAE5D,cAAc,CAAC,MAAM,CAAC,EAAE,QAAQ,GAAG,aAAa;IAUhD,IAAI,eAAe,IAAI,oBAAoB,CAM1C;CACF;AAED,wBAAsB,SAAS,CAAC,UAAU,EAAE,2BAA2B,+BAKtE"}

package/dist/registry_v1/config_schema.d.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+export declare const PlPackageConfigData: z.ZodObject<{
+    organization: z.ZodString;
+    package: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    files: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    meta: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    organization: string;
+    meta: {} & {
+        [k: string]: unknown;
+    };
+    files: Record<string, string>;
+    package: string;
+    version?: string | undefined;
+}, {
+    organization: string;
+    meta: {} & {
+        [k: string]: unknown;
+    };
+    package: string;
+    files?: Record<string, string> | undefined;
+    version?: string | undefined;
+}>;
+export declare const PlRegCommonConfigData: z.ZodObject<{
+    registries: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    registry: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    registries: Record<string, string>;
+    registry?: string | undefined;
+}, {
+    registries?: Record<string, string> | undefined;
+    registry?: string | undefined;
+}>;
+export type PlRegCommonConfigData = z.infer<typeof PlRegCommonConfigData>;
+export declare const PlRegFullPackageConfigData: z.ZodObject<{
+    organization: z.ZodString;
+    meta: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+    files: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    version: z.ZodString;
+    package: z.ZodString;
+    registries: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    registry: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    organization: string;
+    meta: {} & {
+        [k: string]: unknown;
+    };
+    files: Record<string, string>;
+    version: string;
+    package: string;
+    registries: Record<string, string>;
+    registry: string;
+}, {
+    organization: string;
+    meta: {} & {
+        [k: string]: unknown;
+    };
+    version: string;
+    package: string;
+    registry: string;
+    files?: Record<string, string> | undefined;
+    registries?: Record<string, string> | undefined;
+}>;
+export type PlRegFullPackageConfigData = z.infer<typeof PlRegFullPackageConfigData>;
+export declare const PlRegPackageConfigDataShard: z.ZodObject<{
+    organization: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>>;
+    files: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    version: z.ZodOptional<z.ZodString>;
+    package: z.ZodOptional<z.ZodString>;
+    registries: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    registry: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    files: Record<string, string>;
+    registries: Record<string, string>;
+    organization?: string | undefined;
+    meta?: z.objectOutputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    version?: string | undefined;
+    package?: string | undefined;
+    registry?: string | undefined;
+}, {
+    organization?: string | undefined;
+    meta?: z.objectInputType<{}, z.ZodTypeAny, "passthrough"> | undefined;
+    files?: Record<string, string> | undefined;
+    version?: string | undefined;
+    package?: string | undefined;
+    registries?: Record<string, string> | undefined;
+    registry?: string | undefined;
+}>;
+export type PlRegPackageConfigDataShard = z.infer<typeof PlRegPackageConfigDataShard>;
+export declare const PlPackageJsonConfigFile = "pl.package.json";
+export declare const PlPackageYamlConfigFile = "pl.package.yaml";
+//# sourceMappingURL=config_schema.d.ts.map

package/dist/registry_v1/config_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config_schema.d.ts","sourceRoot":"","sources":["../../src/registry_v1/config_schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;EAM9B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;EAGhC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEtC,CAAC;AACF,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AACpF,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;EAGtC,CAAC;AACH,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC;AAEtF,eAAO,MAAM,uBAAuB,oBAAoB,CAAC;AACzD,eAAO,MAAM,uBAAuB,oBAAoB,CAAC"}

package/dist/registry_v1/flags.d.ts

@@ -0,0 +1,9 @@
+export interface TargetFile {
+    src: string;
+    destName: string;
+}
+export declare const targetFile: import('@oclif/core/interfaces').FlagDefinition<TargetFile, import('@oclif/core/interfaces').CustomOptions, {
+    multiple: false;
+    requiredOrDefaulted: false;
+}>;
+//# sourceMappingURL=flags.d.ts.map

package/dist/registry_v1/flags.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../src/registry_v1/flags.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC;CAClB;AAYD,eAAO,MAAM,UAAU;;;EAIrB,CAAC"}

package/dist/registry_v1/index.d.ts

@@ -0,0 +1,4 @@
+export * from './v1_repo_schema';
+export * from './config_schema';
+export { PlRegPackageConfig } from './config';
+//# sourceMappingURL=index.d.ts.map

package/dist/registry_v1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/registry_v1/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC"}

package/dist/registry_v1/registry.d.ts

@@ -0,0 +1,46 @@
+import { RegistryStorage } from '../lib/storage';
+import { BlockPackageNameWithoutVersion, FullBlockPackageName, GlobalOverview, PackageOverview } from './v1_repo_schema';
+import { MiLogger } from '@milaboratories/ts-helpers';
+/**
+ * Layout:
+ *
+ *   _updates_v1/per_package/
+ *     organisationA/package1/1.2.3/seedABC    <-- Tells that change happened for organisationA/package1 version 1.2.3, and reassembly of package1 overview is required
+ *     organisationA/package1/1.2.3/seedCDE
+ *     organisationB/package2/1.4.3/seedFGH
+ *
+ *   _updates_v1/_global_update_in             <-- Anybody who changes contents writes a random seed in this file
+ *   _updates_v1/_global_update_out            <-- Update process writes update seed from the _global_update_in here after successful update.
+ *                                                 Mismatch between contents of those files is a sign that another update should be performed.
+ *
+ *   v1/                                       <-- Actual block packages content
+ *     organisationA/package2/1.2.3/meta.json
+ *     organisationA/package2/1.2.3/main.template.plj.gz
+ *     organisationA/package2/1.2.3/...
+ *     organisationA/package2/overview.json    <-- Per-package aggregated meta-data over all available versions
+ *     ...
+ *
+ *   v1/overview.json                          <-- aggregated information about all packages
+ *
+ */
+export declare class BlockRegistry {
+    private readonly storage;
+    private readonly logger?;
+    constructor(storage: RegistryStorage, logger?: MiLogger | undefined);
+    constructNewPackage(pack: FullBlockPackageName): BlockRegistryPackConstructor;
+    private updateRegistry;
+    updateIfNeeded(force?: boolean): Promise<void>;
+    getPackageOverview(name: BlockPackageNameWithoutVersion): Promise<undefined | PackageOverview>;
+    getGlobalOverview(): Promise<undefined | GlobalOverview>;
+}
+export declare class BlockRegistryPackConstructor {
+    private readonly storage;
+    readonly name: FullBlockPackageName;
+    private metaAdded;
+    readonly seed: `${string}-${string}-${string}-${string}-${string}`;
+    constructor(storage: RegistryStorage, name: FullBlockPackageName);
+    addFile(file: string, content: Buffer): Promise<void>;
+    writeMeta(meta: object): Promise<void>;
+    finish(): Promise<void>;
+}
+//# sourceMappingURL=registry.d.ts.map

package/dist/registry_v1/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/registry_v1/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAGjD,OAAO,EACL,8BAA8B,EAC9B,oBAAoB,EACpB,cAAc,EAGd,eAAe,EAGhB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAyCtD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qBAAa,aAAa;IAEtB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;gBADP,OAAO,EAAE,eAAe,EACxB,MAAM,CAAC,EAAE,QAAQ,YAAA;IAGpC,mBAAmB,CAAC,IAAI,EAAE,oBAAoB,GAAG,4BAA4B;YAI/D,cAAc;IAoGtB,cAAc,CAAC,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBrD,kBAAkB,CACtB,IAAI,EAAE,8BAA8B,GACnC,OAAO,CAAC,SAAS,GAAG,eAAe,CAAC;IAMjC,iBAAiB,IAAI,OAAO,CAAC,SAAS,GAAG,cAAc,CAAC;CAK/D;AAED,qBAAa,4BAA4B;IAKrC,OAAO,CAAC,QAAQ,CAAC,OAAO;aACR,IAAI,EAAE,oBAAoB;IAL5C,OAAO,CAAC,SAAS,CAAkB;IACnC,SAAgB,IAAI,sDAAgB;gBAGjB,OAAO,EAAE,eAAe,EACzB,IAAI,EAAE,oBAAoB;IAGtC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD,SAAS,CAAC,IAAI,EAAE,MAAM;IAKtB,MAAM;CAKb"}

package/dist/registry_v1/v1_repo_schema.d.ts

@@ -0,0 +1,25 @@
+export interface FullBlockPackageName {
+    organization: string;
+    package: string;
+    version: string;
+}
+export declare function packageContentPrefix(bp: FullBlockPackageName): string;
+export declare function payloadFilePath(bp: FullBlockPackageName, file: string): string;
+export type BlockPackageNameWithoutVersion = Pick<FullBlockPackageName, 'organization' | 'package'>;
+export declare function packageOverviewPath(bp: BlockPackageNameWithoutVersion): string;
+export declare const GlobalOverviewPath = "v1/overview.json";
+export declare const MetaFile = "meta.json";
+export interface PackageOverviewEntry {
+    version: string;
+    meta: object;
+}
+export type PackageOverview = PackageOverviewEntry[];
+export interface GlobalOverviewEntry {
+    organization: string;
+    package: string;
+    allVersions: string[];
+    latestVersion: string;
+    latestMeta: object;
+}
+export type GlobalOverview = GlobalOverviewEntry[];
+//# sourceMappingURL=v1_repo_schema.d.ts.map

package/dist/registry_v1/v1_repo_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v1_repo_schema.d.ts","sourceRoot":"","sources":["../../src/registry_v1/v1_repo_schema.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAID,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,oBAAoB,GAAG,MAAM,CAErE;AAED,wBAAgB,eAAe,CAAC,EAAE,EAAE,oBAAoB,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED,MAAM,MAAM,8BAA8B,GAAG,IAAI,CAAC,oBAAoB,EAAE,cAAc,GAAG,SAAS,CAAC,CAAC;AAEpG,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,8BAA8B,GAAG,MAAM,CAE9E;AAED,eAAO,MAAM,kBAAkB,qBAA+B,CAAC;AAE/D,eAAO,MAAM,QAAQ,cAAc,CAAC;AAEpC,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,eAAe,GAAG,oBAAoB,EAAE,CAAC;AAErD,MAAM,WAAW,mBAAmB;IAClC,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,MAAM,cAAc,GAAG,mBAAmB,EAAE,CAAC"}

package/dist/util.d.ts

@@ -0,0 +1,4 @@
+import { BigIntStats } from 'node:fs';
+export declare function tryLoadFile<T>(file: string, map: (buf: Buffer) => T): Promise<T | undefined>;
+export declare function tryStat(path: string): Promise<BigIntStats | undefined>;
+//# sourceMappingURL=util.d.ts.map

package/dist/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAGtC,wBAAsB,WAAW,CAAC,CAAC,EACjC,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,CAAC,GACtB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAOxB;AAED,wBAAsB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,SAAS,CAAC,CAS5E"}

package/dist/v2/build_dist.d.ts

@@ -0,0 +1,3 @@
+import { BlockPackDescriptionAbsolute, BlockPackManifest } from './model';
+export declare function buildBlockPackDist(description: BlockPackDescriptionAbsolute, dst: string): Promise<BlockPackManifest>;
+//# sourceMappingURL=build_dist.d.ts.map

package/dist/v2/build_dist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build_dist.d.ts","sourceRoot":"","sources":["../../src/v2/build_dist.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAG5B,iBAAiB,EAElB,MAAM,SAAS,CAAC;AAMjB,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,4BAA4B,EACzC,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,iBAAiB,CAAC,CAa5B"}

package/dist/v2/index.d.ts

@@ -0,0 +1,4 @@
+export * from './model';
+export * from './build_dist';
+export * from './source_package';
+//# sourceMappingURL=index.d.ts.map

package/dist/v2/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/v2/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC"}

package/dist/v2/model/block_components.d.ts

@@ -0,0 +1,384 @@
+import { z } from 'zod';
+export declare function BlockComponentsDescription(moduleRoot: string): z.ZodObject<{
+    workflow: z.ZodEffects<z.ZodString, {
+        type: "absolute-file";
+        file: string;
+    }, string>;
+    model: z.ZodEffects<z.ZodString, {
+        type: "absolute-file";
+        file: string;
+    }, string>;
+    ui: z.ZodEffects<z.ZodString, {
+        type: "absolute-folder";
+        folder: string;
+    }, string>;
+}, "strip", z.ZodTypeAny, {
+    workflow: {
+        type: "absolute-file";
+        file: string;
+    };
+    model: {
+        type: "absolute-file";
+        file: string;
+    };
+    ui: {
+        type: "absolute-folder";
+        folder: string;
+    };
+}, {
+    workflow: string;
+    model: string;
+    ui: string;
+}>;
+export type BlockComponentsDescription = z.infer<ReturnType<typeof BlockComponentsDescription>>;
+export declare function BlockComponentsConsolidate(dstFolder: string, fileAccumulator?: string[]): z.ZodPipeline<z.ZodObject<{
+    workflow: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"explicit-base64">;
+        mimeType: z.ZodString;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"absolute-file">;
+        file: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "absolute-file";
+        file: string;
+    }, {
+        type: "absolute-file";
+        file: string;
+    }>]>, {
+        type: "relative";
+        path: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-file";
+        file: string;
+    }>;
+    model: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"explicit-base64">;
+        mimeType: z.ZodString;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"absolute-file">;
+        file: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "absolute-file";
+        file: string;
+    }, {
+        type: "absolute-file";
+        file: string;
+    }>]>, {
+        type: "relative";
+        path: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-file";
+        file: string;
+    }>;
+    ui: z.ZodEffects<z.ZodObject<{
+        type: z.ZodLiteral<"absolute-folder">;
+        folder: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "absolute-folder";
+        folder: string;
+    }, {
+        type: "absolute-folder";
+        folder: string;
+    }>, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "absolute-folder";
+        folder: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    workflow: {
+        type: "relative";
+        path: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    };
+    model: {
+        type: "relative";
+        path: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    };
+    ui: {
+        type: "relative";
+        path: string;
+    };
+}, {
+    workflow: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-file";
+        file: string;
+    };
+    model: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-file";
+        file: string;
+    };
+    ui: {
+        type: "absolute-folder";
+        folder: string;
+    };
+}>, z.ZodObject<{
+    workflow: z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "relative";
+        path: string;
+    }>;
+    model: z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "relative";
+        path: string;
+    }>;
+    ui: z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "relative";
+        path: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    ui: {
+        type: "relative";
+        path: string;
+    };
+    workflow: {
+        type: "relative";
+        path: string;
+    };
+    model: {
+        type: "relative";
+        path: string;
+    };
+}, {
+    ui: {
+        type: "relative";
+        path: string;
+    };
+    workflow: {
+        type: "relative";
+        path: string;
+    };
+    model: {
+        type: "relative";
+        path: string;
+    };
+}>>;
+export declare function BlockComponentsAbsoluteUrl(prefix: string): z.ZodObject<{
+    workflow: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"explicit-base64">;
+        mimeType: z.ZodString;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "relative";
+        path: string;
+    }>]>, {
+        type: "absolute-url";
+        url: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "relative";
+        path: string;
+    }>;
+    model: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"explicit-base64">;
+        mimeType: z.ZodString;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "relative";
+        path: string;
+    }>]>, {
+        type: "absolute-url";
+        url: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "relative";
+        path: string;
+    }>;
+    ui: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"explicit-base64">;
+        mimeType: z.ZodString;
+        content: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }>, z.ZodObject<{
+        type: z.ZodLiteral<"relative">;
+        path: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        type: "relative";
+        path: string;
+    }, {
+        type: "relative";
+        path: string;
+    }>]>, {
+        type: "absolute-url";
+        url: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "relative";
+        path: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    workflow: {
+        type: "absolute-url";
+        url: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    };
+    model: {
+        type: "absolute-url";
+        url: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    };
+    ui: {
+        type: "absolute-url";
+        url: string;
+    } | {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    };
+}, {
+    workflow: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "relative";
+        path: string;
+    };
+    model: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "relative";
+        path: string;
+    };
+    ui: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "relative";
+        path: string;
+    };
+}>;
+export type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;
+//# sourceMappingURL=block_components.d.ts.map

package/dist/v2/model/block_components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_components.d.ts","sourceRoot":"","sources":["../../../src/v2/model/block_components.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAK5D;AACD,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC;AAEhG,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,CAAC,EAAE,MAAM,EAAE;;gBAc6hN,UAAU;oBAAqC,SAAS;mBAAiB,SAAS;;;;;;;;;;gBAAkN,UAAU;gBAA+B,SAAS;;;;;;;;;;;;;;;;;;;;;;;gBAAtV,UAAU;oBAAqC,SAAS;mBAAiB,SAAS;;;;;;;;;;gBAAkN,UAAU;gBAA+B,SAAS;;;;;;;;;;;;;;;;;;;;;;;gBAAtqM,UAAU;kBAAmC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA/I,SAAS;gBAAmB,UAAU;gBAA8B,SAAS;mBAAqB,UAAU;;;;;;;aAAkI,SAAS;gBAAmB,UAAU;gBAA8B,SAAS;mBAAqB,UAAU;;;;;;;UAA+H,SAAS;gBAAmB,UAAU;gBAA8B,SAAS;mBAAqB,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAThxC;AAED,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM;;gBAO22Q,UAAU;oBAAqC,SAAS;mBAAiB,SAAS;;;;;;;;;;gBAAkN,UAAU;gBAA0B,SAAS;;;;;;;;;;;;;;;;;;;;;;;gBAAjV,UAAU;oBAAqC,SAAS;mBAAiB,SAAS;;;;;;;;;;gBAAkN,UAAU;gBAA0B,SAAS;;;;;;;;;;;;;;;;;;;;;;;gBAAjV,UAAU;oBAAqC,SAAS;mBAAiB,SAAS;;;;;;;;;;gBAAkN,UAAU;gBAA0B,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAFpvR;AACD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC"}

package/dist/v2/model/common.d.ts

@@ -0,0 +1,3 @@
+export type ContextType = 'local' | 'remote';
+export type ContentType = 'text' | 'binary';
+//# sourceMappingURL=common.d.ts.map

package/dist/v2/model/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/v2/model/common.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,QAAQ,CAAC;AAC7C,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,QAAQ,CAAC"}