@inlang/sdk 0.35.4 → 0.35.6

package/dist/v2/mocks/multipleMatcher/bundle.js

@@ -0,0 +1,194 @@
+export const multipleMatcherBundle = {
+    id: "mock-bundle-human-id",
+    alias: {
+        default: "mock-bundle-alias",
+    },
+    messages: [
+        {
+            locale: "en",
+            declarations: [],
+            selectors: [
+                {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: "count",
+                    },
+                    annotation: { type: "function", name: "plural", options: [] },
+                },
+            ],
+            variants: [
+                {
+                    match: ["one"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Show ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " message.",
+                        },
+                    ],
+                },
+                {
+                    match: ["many"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Show ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " messages.",
+                        },
+                    ],
+                },
+                {
+                    match: ["*"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Show ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+        {
+            locale: "de",
+            declarations: [],
+            selectors: [
+                {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: "count",
+                    },
+                    annotation: { type: "function", name: "plural", options: [] },
+                },
+                {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: "formal",
+                    },
+                    annotation: { type: "function", name: "bool", options: [] },
+                },
+            ],
+            variants: [
+                {
+                    match: ["one", "formal"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeigen Sie bitte Ihre Nachricht.",
+                        },
+                    ],
+                },
+                {
+                    match: ["one", "informal"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeigen Deine Nachricht.",
+                        },
+                    ],
+                },
+                {
+                    match: ["many", "formal"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeigen Sie bitte Ihre ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " Nachrichten.",
+                        },
+                    ],
+                },
+                {
+                    match: ["many", "informal"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeigen Deine ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " Nachrichten.",
+                        },
+                    ],
+                },
+                {
+                    match: ["many", "*"],
+                    pattern: [
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                        {
+                            type: "text",
+                            value: " Nachrichten zeigen.",
+                        },
+                    ],
+                },
+                {
+                    match: ["*"],
+                    pattern: [
+                        {
+                            type: "text",
+                            value: "Zeige ",
+                        },
+                        {
+                            type: "expression",
+                            arg: {
+                                type: "variable",
+                                name: "count",
+                            },
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};

package/dist/v2/mocks/multipleMatcher/bundle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bundle.test.d.ts.map

package/dist/v2/mocks/multipleMatcher/bundle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.test.d.ts","sourceRoot":"","sources":["../../../../src/v2/mocks/multipleMatcher/bundle.test.ts"],"names":[],"mappings":""}

package/dist/v2/mocks/multipleMatcher/bundle.test.js

@@ -0,0 +1,10 @@
+import { describe, it, expect } from "vitest";
+import { multipleMatcherBundle } from "./bundle.js";
+import { MessageBundle } from "../../types.js";
+import { Value } from "@sinclair/typebox/value";
+describe("mock plural messageBundle", () => {
+    it("is valid", () => {
+        const messageBundle = multipleMatcherBundle;
+        expect(Value.Check(MessageBundle, messageBundle)).toBe(true);
+    });
+});

package/dist/v2/mocks/plural/bundle.d.ts

@@ -1,3 +1,3 @@
 import type { MessageBundle } from "../../types.js";
-export declare const bundle: MessageBundle;
+export declare const pluralBundle: MessageBundle;
 //# sourceMappingURL=bundle.d.ts.map

package/dist/v2/mocks/plural/bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../../src/v2/mocks/plural/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,eAAO,MAAM,MAAM,EAAE,aA2IpB,CAAA"}
+{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../../../../src/v2/mocks/plural/bundle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD,eAAO,MAAM,YAAY,EAAE,aA2I1B,CAAA"}

package/dist/v2/mocks/plural/bundle.js

@@ -1,4 +1,4 @@
-export const bundle = {
+export const pluralBundle = {
     id: "mock_bundle_human_id",
     alias: {
         default: "mock_bundle_alias",

package/dist/v2/mocks/plural/bundle.test.js

@@ -1,15 +1,15 @@
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { describe, it, expect } from "vitest";
-import { bundle } from "./bundle.js";
+import { pluralBundle } from "./bundle.js";
 import { MessageBundle } from "../../types.js";
 import { Value } from "@sinclair/typebox/value";
 describe("mock plural messageBundle", () => {
     it("is valid", () => {
-        const messageBundle = bundle;
+        const messageBundle = pluralBundle;
         expect(Value.Check(MessageBundle, messageBundle)).toBe(true);
-        expect(bundle.messages.length).toBe(2);
-        expect(bundle.messages[0].declarations.length).toBe(1);
-        expect(bundle.messages[0].selectors.length).toBe(1);
-        expect(bundle.messages[0].variants.length).toBe(3);
+        expect(pluralBundle.messages.length).toBe(2);
+        expect(pluralBundle.messages[0].declarations.length).toBe(1);
+        expect(pluralBundle.messages[0].selectors.length).toBe(1);
+        expect(pluralBundle.messages[0].variants.length).toBe(3);
     });
 });

package/dist/v2/shim.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Convert between v1 Message and v2 MessageBundle formats.
+ * Code adapted from https://github.com/opral/monorepo/pull/2655 legacy.ts
+ */
+import * as V2 from "./types.js";
+import * as V1 from "@inlang/message";
+/**
+ * @throws If the message cannot be represented in the v1 format
+ */
+export declare function toV1Message(bundle: V2.MessageBundle): V1.Message;
+export declare function fromV1Message(v1Message: V1.Message): V2.MessageBundle;
+//# sourceMappingURL=shim.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shim.d.ts","sourceRoot":"","sources":["../../src/v2/shim.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,YAAY,CAAA;AAChC,OAAO,KAAK,EAAE,MAAM,iBAAiB,CAAA;AAErC;;GAEG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC,aAAa,GAAG,EAAE,CAAC,OAAO,CA+BhE;AAwCD,wBAAgB,aAAa,CAAC,SAAS,EAAE,EAAE,CAAC,OAAO,GAAG,EAAE,CAAC,aAAa,CAgErE"}

package/dist/v2/shim.js

@@ -0,0 +1,151 @@
+/**
+ * Convert between v1 Message and v2 MessageBundle formats.
+ * Code adapted from https://github.com/opral/monorepo/pull/2655 legacy.ts
+ */
+import * as V2 from "./types.js";
+import * as V1 from "@inlang/message";
+/**
+ * @throws If the message cannot be represented in the v1 format
+ */
+export function toV1Message(bundle) {
+    const variants = [];
+    const selectorNames = new Set();
+    for (const message of bundle.messages) {
+        // collect all selector names
+        for (const selector of message.selectors.map(toV1Expression)) {
+            selectorNames.add(selector.name);
+        }
+        // collect all variants
+        for (const variant of message.variants) {
+            variants.push({
+                languageTag: message.locale,
+                match: variant.match,
+                pattern: toV1Pattern(variant.pattern),
+            });
+        }
+    }
+    const selectors = [...selectorNames].map((name) => ({
+        type: "VariableReference",
+        name,
+    }));
+    return {
+        id: bundle.id,
+        alias: bundle.alias,
+        variants,
+        selectors,
+    };
+}
+/**
+ * @throws If the pattern cannot be represented in the v1 format
+ */
+function toV1Pattern(pattern) {
+    return pattern.map((element) => {
+        switch (element.type) {
+            case "text": {
+                return {
+                    type: "Text",
+                    value: element.value,
+                };
+            }
+            case "expression": {
+                return toV1Expression(element);
+            }
+            default: {
+                throw new Error(`Unsupported pattern element type`);
+            }
+        }
+    });
+}
+function toV1Expression(expression) {
+    if (expression.annotation !== undefined)
+        throw new Error("Cannot convert an expression with an annotation to the v1 format");
+    if (expression.arg.type !== "variable") {
+        throw new Error("Can only convert variable references to the v1 format");
+    }
+    return {
+        type: "VariableReference",
+        name: expression.arg.name,
+    };
+}
+export function fromV1Message(v1Message) {
+    const languages = dedup(v1Message.variants.map((variant) => variant.languageTag));
+    const messages = languages.map((language) => {
+        //All variants that will be part of this message
+        const v1Variants = v1Message.variants.filter((variant) => variant.languageTag === language);
+        //find all selector names
+        const selectorNames = new Set();
+        for (const v1Selector of v1Message.selectors) {
+            selectorNames.add(v1Selector.name);
+        }
+        const selectors = [...selectorNames].map((name) => ({
+            type: "expression",
+            annotation: undefined,
+            arg: {
+                type: "variable",
+                name: name,
+            },
+        }));
+        //The set of variables that need to be defined - Certainly includes the selectors
+        const variableNames = new Set(selectorNames);
+        const variants = [];
+        for (const v1Variant of v1Variants) {
+            for (const element of v1Variant.pattern) {
+                if (element.type === "VariableReference") {
+                    variableNames.add(element.name);
+                }
+            }
+            variants.push({
+                match: v1Variant.match,
+                pattern: fromV1Pattern(v1Variant.pattern),
+            });
+        }
+        //Create an input declaration for each variable and selector we need
+        const declarations = [...variableNames].map((name) => ({
+            type: "input",
+            name,
+            value: {
+                type: "expression",
+                annotation: undefined,
+                arg: {
+                    type: "variable",
+                    name,
+                },
+            },
+        }));
+        return {
+            locale: language,
+            declarations,
+            selectors,
+            variants,
+        };
+    });
+    return {
+        id: v1Message.id,
+        alias: v1Message.alias,
+        messages,
+    };
+}
+function fromV1Pattern(pattern) {
+    return pattern.map((element) => {
+        switch (element.type) {
+            case "Text": {
+                return {
+                    type: "text",
+                    value: element.value,
+                };
+            }
+            case "VariableReference":
+                return {
+                    type: "expression",
+                    arg: {
+                        type: "variable",
+                        name: element.name,
+                    },
+                };
+        }
+    });
+}
+/**
+ * Dedups an array by converting it to a set and back
+ */
+const dedup = (arr) => [...new Set(arr)];

package/dist/v2/shim.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=shim.test.d.ts.map

package/dist/v2/shim.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shim.test.d.ts","sourceRoot":"","sources":["../../src/v2/shim.test.ts"],"names":[],"mappings":""}

package/dist/v2/shim.test.js

@@ -0,0 +1,49 @@
+import { test, expect } from "vitest";
+import * as V2 from "./types.js";
+import * as V1 from "@inlang/message";
+import { createMessageBundle, createMessage } from "./helper.js";
+import { toV1Message, fromV1Message } from "./shim.js";
+import { Value } from "@sinclair/typebox/value";
+const bundle = createMessageBundle({
+    id: "hello_world",
+    messages: [
+        createMessage({ locale: "en", text: "Hello World!" }),
+        createMessage({ locale: "de", text: "Hallo Welt!" }),
+    ],
+});
+test("toV1Message and fromV1Message", () => {
+    expect(Value.Check(V2.MessageBundle, bundle)).toBe(true);
+    const v1Message = toV1Message(bundle);
+    expect(Value.Check(V1.Message, v1Message)).toBe(true);
+    expect(v1Message).toEqual({
+        id: "hello_world",
+        alias: {},
+        variants: [
+            {
+                languageTag: "en",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "Hello World!",
+                    },
+                ],
+            },
+            {
+                languageTag: "de",
+                match: [],
+                pattern: [
+                    {
+                        type: "Text",
+                        value: "Hallo Welt!",
+                    },
+                ],
+            },
+        ],
+        selectors: [],
+    });
+    const v2MessageBundle = fromV1Message(v1Message);
+    expect(Value.Check(V2.MessageBundle, v2MessageBundle)).toBe(true);
+    expect(v2MessageBundle).toEqual(bundle);
+});
+test.todo("with variable references", () => { });

package/dist/v2/stubQueryApi.d.ts

@@ -0,0 +1,9 @@
+import type { MessageQueryApi, MessageLintReportsQueryApi } from "../api.js";
+/**
+ * noop implementation of the message query api for use with experimental.persistence = true.
+ * NOTE: If we implemented v2 shims for the old api we could use existing tests and make apps
+ * backwards compatible.
+ */
+export declare const stubMessagesQuery: MessageQueryApi;
+export declare const stubMessageLintReportsQuery: MessageLintReportsQueryApi;
+//# sourceMappingURL=stubQueryApi.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stubQueryApi.d.ts","sourceRoot":"","sources":["../../src/v2/stubQueryApi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,0BAA0B,EAAE,MAAM,WAAW,CAAA;AAE5E;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,eAc/B,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,0BAKzC,CAAA"}

package/dist/v2/stubQueryApi.js

@@ -0,0 +1,38 @@
+/**
+ * noop implementation of the message query api for use with experimental.persistence = true.
+ * NOTE: If we implemented v2 shims for the old api we could use existing tests and make apps
+ * backwards compatible.
+ */
+export const stubMessagesQuery = {
+    create: () => false,
+    // @ts-expect-error
+    get: subscribable(() => undefined),
+    // @ts-expect-error
+    getByDefaultAlias: subscribable(() => undefined),
+    // @ts-expect-error
+    includedMessageIds: subscribable(() => []),
+    // @ts-expect-error
+    getAll: subscribable(() => []),
+    update: () => false,
+    upsert: () => { },
+    delete: () => false,
+    setDelegate: () => { },
+};
+export const stubMessageLintReportsQuery = {
+    // @ts-expect-error
+    get: subscribable(() => []),
+    // @ts-expect-error
+    getAll: settleable(subscribable(() => [])),
+};
+// eslint-disable-next-line @typescript-eslint/ban-types
+function subscribable(fn) {
+    return Object.assign(fn, {
+        subscribe: () => { },
+    });
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function settleable(fn) {
+    return Object.assign(fn, {
+        settled: async () => { },
+    });
+}

package/dist/v2/types.d.ts

@@ -408,4 +408,114 @@ export declare const MessageBundle: import("@sinclair/typebox").TObject<{
         }>>;
     }>>;
 }>;
+/**
+ * A MessageSlot is a placeholder for a message with a locale.
+ * This is useful to avoid merge conflicts when translations are added.
+ */
+export type MessageSlot = Static<typeof MessageSlot>;
+export declare const MessageSlot: import("@sinclair/typebox").TObject<{
+    locale: import("@sinclair/typebox").TString;
+    slot: import("@sinclair/typebox").TLiteral<true>;
+}>;
+export type MessageBundleWithSlots = Static<typeof MessageBundleWithSlots>;
+export declare const MessageBundleWithSlots: import("@sinclair/typebox").TObject<{
+    id: import("@sinclair/typebox").TString;
+    alias: import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TString>;
+    messages: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+        locale: import("@sinclair/typebox").TString;
+        declarations: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            type: import("@sinclair/typebox").TLiteral<"input">;
+            name: import("@sinclair/typebox").TString;
+            value: import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"expression">;
+                arg: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"literal">;
+                    value: import("@sinclair/typebox").TString;
+                }>, import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"variable">;
+                    name: import("@sinclair/typebox").TString;
+                }>]>;
+                annotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"function">;
+                    name: import("@sinclair/typebox").TString;
+                    options: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                        name: import("@sinclair/typebox").TString;
+                        value: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                            type: import("@sinclair/typebox").TLiteral<"literal">;
+                            value: import("@sinclair/typebox").TString;
+                        }>, import("@sinclair/typebox").TObject<{
+                            type: import("@sinclair/typebox").TLiteral<"variable">;
+                            name: import("@sinclair/typebox").TString;
+                        }>]>;
+                    }>>;
+                }>>;
+            }>;
+        }>>;
+        /**
+         * The order in which the selectors are placed determines the precedence of patterns.
+         */
+        selectors: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            type: import("@sinclair/typebox").TLiteral<"expression">;
+            arg: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"literal">;
+                value: import("@sinclair/typebox").TString;
+            }>, import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"variable">;
+                name: import("@sinclair/typebox").TString;
+            }>]>;
+            annotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"function">;
+                name: import("@sinclair/typebox").TString;
+                options: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                    name: import("@sinclair/typebox").TString;
+                    value: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                        type: import("@sinclair/typebox").TLiteral<"literal">;
+                        value: import("@sinclair/typebox").TString;
+                    }>, import("@sinclair/typebox").TObject<{
+                        type: import("@sinclair/typebox").TLiteral<"variable">;
+                        name: import("@sinclair/typebox").TString;
+                    }>]>;
+                }>>;
+            }>>;
+        }>>;
+        variants: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            /**
+             * The number of keys in each variant match MUST equal the number of expressions in the selectors.
+             *
+             * Inspired by: https://github.com/unicode-org/message-format-wg/blob/main/spec/formatting.md#pattern-selection
+             */
+            match: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>;
+            pattern: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"text">;
+                value: import("@sinclair/typebox").TString;
+            }>, import("@sinclair/typebox").TObject<{
+                type: import("@sinclair/typebox").TLiteral<"expression">;
+                arg: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"literal">;
+                    value: import("@sinclair/typebox").TString;
+                }>, import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"variable">;
+                    name: import("@sinclair/typebox").TString;
+                }>]>;
+                annotation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TObject<{
+                    type: import("@sinclair/typebox").TLiteral<"function">;
+                    name: import("@sinclair/typebox").TString;
+                    options: import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+                        name: import("@sinclair/typebox").TString;
+                        value: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TObject<{
+                            type: import("@sinclair/typebox").TLiteral<"literal">;
+                            value: import("@sinclair/typebox").TString;
+                        }>, import("@sinclair/typebox").TObject<{
+                            type: import("@sinclair/typebox").TLiteral<"variable">;
+                            name: import("@sinclair/typebox").TString;
+                        }>]>;
+                    }>>;
+                }>>;
+            }>]>>;
+        }>>;
+    }>, import("@sinclair/typebox").TObject<{
+        locale: import("@sinclair/typebox").TString;
+        slot: import("@sinclair/typebox").TLiteral<true>;
+    }>]>>;
+}>;
 //# sourceMappingURL=types.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/v2/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAErD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD;;;GAGG;AAEH,eAAO,MAAM,OAAO,sbACga,CAAA;AAEpb,eAAO,MAAM,WAAW,qCAItB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,OAAO;;;EAGlB,CAAA;AAEF;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC,OAAO,IAAI,CAAC,CAAA;AACtC,eAAO,MAAM,IAAI;;;EAGf,CAAA;AAEF,MAAM,MAAM,iBAAiB,GAAG,MAAM,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAChE,eAAO,MAAM,iBAAiB;;;EAG5B,CAAA;AAEF,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,OAAO,MAAM,CAAC,CAAA;AAC1C,eAAO,MAAM,MAAM;;;;;;;;;EAGjB,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAClE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;EAI7B,CAAA;AAEF;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,OAAO,UAAU,CAAC,CAAA;AAClD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;EAIrB,CAAA;AASF;;;GAGG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6C,CAAA;AAEjE;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,OAAO;IACnB;;;;OAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAIF,CAAA;AAEF,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC9D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAM3B,CAAA;AAgBF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;EAAiC,CAAA;AAEzD,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,OAAO,CAAC,CAAA;AAC5C,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAGnB;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;QA1CH;;;;WAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCF,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,aAAa,CAAC,CAAA;AACxD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QARzB;;WAEG;;;;;;;;;;;;;;;;;;;;;;;;;;YA1CH;;;;eAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgDF,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/v2/types.ts"],"names":[],"mappings":"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"}