@milaboratories/pl-model-middle-layer 1.2.16 → 1.2.18

package/dist/author_marker.d.ts

@@ -0,0 +1,10 @@
+/** Structure to help resolve conflicts if multiple participants writes to
+ * the same state */
+export interface AuthorMarker {
+    /** Unique identifier of client or even a specific window that sets this
+     * particular state */
+    authorId: string;
+    /** Sequential version of the state local to the author */
+    localVersion: number;
+}
+//# sourceMappingURL=author_marker.d.ts.map

package/dist/author_marker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"author_marker.d.ts","sourceRoot":"","sources":["../src/author_marker.ts"],"names":[],"mappings":"AAAA;oBACoB;AACpB,MAAM,WAAW,YAAY;IAC3B;0BACsB;IACtB,QAAQ,EAAE,MAAM,CAAC;IAEjB,0DAA0D;IAC1D,YAAY,EAAE,MAAM,CAAC;CACtB"}

package/dist/block_meta/block_components.d.ts

@@ -0,0 +1,277 @@
+import { z } from 'zod';
+export type BlockPackComponents = {};
+export declare function Workflow<const Content extends z.ZodTypeAny>(contentType: Content): z.ZodUnion<[z.ZodEffects<Content, {
+    type: string;
+    main: any;
+}, z.input<Content>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+    type: z.ZodLiteral<"workflow-v1">;
+    main: Content;
+}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    type: z.ZodLiteral<"workflow-v1">;
+    main: Content;
+}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    type: z.ZodLiteral<"workflow-v1">;
+    main: Content;
+}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
+    type: z.ZodLiteral<"workflow-v1">;
+    main: Content;
+}>]: z.baseObjectInputType<{
+    type: z.ZodLiteral<"workflow-v1">;
+    main: Content;
+}>[k_1]; }>]>]>;
+export declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, const UI extends z.ZodTypeAny>(wfAndModel: WfAndModel, ui: UI): z.ZodObject<{
+    workflow: WfAndModel;
+    model: WfAndModel;
+    ui: UI;
+}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    workflow: WfAndModel;
+    model: WfAndModel;
+    ui: UI;
+}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    workflow: WfAndModel;
+    model: WfAndModel;
+    ui: UI;
+}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
+    workflow: WfAndModel;
+    model: WfAndModel;
+    ui: UI;
+}>]: z.baseObjectInputType<{
+    workflow: WfAndModel;
+    model: WfAndModel;
+    ui: UI;
+}>[k_1]; }>;
+export declare const BlockComponentsDescriptionRaw: z.ZodObject<{
+    workflow: z.ZodString;
+    model: z.ZodString;
+    ui: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    ui: string;
+    workflow: string;
+    model: string;
+}, {
+    ui: string;
+    workflow: string;
+    model: string;
+}>;
+export type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;
+export declare const BlockComponentsManifest: 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 type BlockComponentsManifest = z.infer<typeof BlockComponentsManifest>;
+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: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-url";
+        url: 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: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-url";
+        url: 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: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-url";
+        url: string;
+    }, {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "relative";
+        path: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    ui: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-url";
+        url: string;
+    };
+    workflow: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-url";
+        url: string;
+    };
+    model: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "absolute-url";
+        url: string;
+    };
+}, {
+    ui: {
+        type: "explicit-base64";
+        content: string;
+        mimeType: string;
+    } | {
+        type: "relative";
+        path: 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;
+    };
+}>;
+export type BlockComponentsAbsolute = z.infer<ReturnType<typeof BlockComponentsAbsoluteUrl>>;
+//# sourceMappingURL=block_components.d.ts.map

package/dist/block_meta/block_components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_components.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_components.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,MAAM,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAErC,wBAAgB,QAAQ,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO;;;;;;;;;;;;;;;;;;gBAehF;AAED,wBAAgB,eAAe,CAC7B,KAAK,CAAC,UAAU,SAAS,CAAC,CAAC,UAAU,EACrC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,UAAU,EAC7B,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;YAM/B;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;EAA0C,CAAC;AACrF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAE1F,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAoD,CAAC;AACzF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKxD;AACD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC"}

package/dist/block_meta/block_pack_id.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+/** Global identifier of the block */
+export declare const BlockPackId: z.ZodObject<{
+    organization: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    organization: string;
+    name: string;
+    version: string;
+}, {
+    organization: string;
+    name: string;
+    version: string;
+}>;
+export type BlockPackId = z.infer<typeof BlockPackId>;
+export declare const BlockPackIdNoVersion: z.ZodObject<Omit<{
+    organization: z.ZodString;
+    name: z.ZodString;
+    version: z.ZodString;
+}, "version">, "strict", z.ZodTypeAny, {
+    organization: string;
+    name: string;
+}, {
+    organization: string;
+    name: string;
+}>;
+export type BlockPackIdNoVersion = z.infer<typeof BlockPackIdNoVersion>;
+//# sourceMappingURL=block_pack_id.d.ts.map

package/dist/block_meta/block_pack_id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block_pack_id.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_pack_id.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,qCAAqC;AACrC,eAAO,MAAM,WAAW;;;;;;;;;;;;EAMb,CAAC;AACZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD,eAAO,MAAM,oBAAoB;;;;;;;;;;EAAsC,CAAC;AACxE,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/block_meta/common.d.ts

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

package/dist/block_meta/common.d.ts.map

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

package/dist/block_meta/content_conversion.d.ts

@@ -0,0 +1,3 @@
+import { ContentAbsoluteUrl, ContentAnyLocal, ContentRelative } from './content_types';
+export declare function mapRemoteToAbsolute(rootUrl: string): <T extends ContentAnyLocal>(value: T) => Exclude<T, ContentRelative> | ContentAbsoluteUrl;
+//# sourceMappingURL=content_conversion.d.ts.map

package/dist/block_meta/content_conversion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content_conversion.d.ts","sourceRoot":"","sources":["../../src/block_meta/content_conversion.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvF,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,MAAM,GACd,CAAC,CAAC,SAAS,eAAe,EAC3B,KAAK,EAAE,CAAC,KACL,OAAO,CAAC,CAAC,EAAE,eAAe,CAAC,GAAG,kBAAkB,CAMpD"}