@skhema/cli 0.3.1

package/dist/lib/config.d.ts

@@ -0,0 +1,20 @@
+export declare const CLI_CLIENT_ID = "skhema-cli-native";
+export declare const AUTH_BASE_URL: string;
+export declare const OAUTH_SCOPES = "openid profile email";
+export declare const DEVICE_POLL_INTERVAL = 5;
+export declare const DEVICE_CODE_EXPIRY = 900;
+export declare const LOGIN_TIMEOUT = 300000;
+export declare const KEYCHAIN_SERVICE = "com.skhema.cli";
+export declare const KEYCHAIN_ACCOUNT = "default";
+export declare const KEYCHAIN_ACCOUNT_API_KEY = "api-key";
+export declare const CREDENTIALS_DIR = ".skhema";
+export declare const CREDENTIALS_FILE = "credentials.json";
+export declare const API_KEY_FILE = "api-key.json";
+export declare const CONFIG_FILE = "config.json";
+export declare const SKILL_LOCK_FILE = ".skhema-skill-lock.json";
+export declare const API_BASE_URL: string;
+export declare const API_KEY_ENV_VAR = "SKHEMA_API_KEY";
+export declare const MCP_SERVER_URL: string;
+export declare const SUPABASE_URL: string;
+export declare const SUPABASE_PUBLISHABLE_KEY: string;
+//# sourceMappingURL=config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,sBAAsB,CAAA;AAChD,eAAO,MAAM,aAAa,QACgC,CAAA;AAC1D,eAAO,MAAM,YAAY,yBAAyB,CAAA;AAClD,eAAO,MAAM,oBAAoB,IAAI,CAAA;AACrC,eAAO,MAAM,kBAAkB,MAAM,CAAA;AACrC,eAAO,MAAM,aAAa,SAAU,CAAA;AACpC,eAAO,MAAM,gBAAgB,mBAAmB,CAAA;AAChD,eAAO,MAAM,gBAAgB,YAAY,CAAA;AAGzC,eAAO,MAAM,wBAAwB,YAAY,CAAA;AACjD,eAAO,MAAM,eAAe,YAAY,CAAA;AACxC,eAAO,MAAM,gBAAgB,qBAAqB,CAAA;AAClD,eAAO,MAAM,YAAY,iBAAiB,CAAA;AAC1C,eAAO,MAAM,WAAW,gBAAgB,CAAA;AACxC,eAAO,MAAM,eAAe,4BAA4B,CAAA;AAGxD,eAAO,MAAM,YAAY,QAC+B,CAAA;AAGxD,eAAO,MAAM,eAAe,mBAAmB,CAAA;AAO/C,eAAO,MAAM,cAAc,QACwC,CAAA;AAMnE,eAAO,MAAM,YAAY,QACsD,CAAA;AAC/E,eAAO,MAAM,wBAAwB,QAEa,CAAA"}

package/dist/lib/config.js

@@ -0,0 +1,33 @@
+export const CLI_CLIENT_ID = 'skhema-cli-native';
+export const AUTH_BASE_URL = process.env.SKHEMA_AUTH_URL ?? 'https://auth.skhema.com';
+export const OAUTH_SCOPES = 'openid profile email';
+export const DEVICE_POLL_INTERVAL = 5; // seconds
+export const DEVICE_CODE_EXPIRY = 900; // seconds (15 minutes)
+export const LOGIN_TIMEOUT = 300000; // 5 minutes in ms
+export const KEYCHAIN_SERVICE = 'com.skhema.cli';
+export const KEYCHAIN_ACCOUNT = 'default';
+// Distinct keychain account for the stored API key, so it lives alongside — but
+// never overwrites — the OAuth session credential.
+export const KEYCHAIN_ACCOUNT_API_KEY = 'api-key';
+export const CREDENTIALS_DIR = '.skhema';
+export const CREDENTIALS_FILE = 'credentials.json';
+export const API_KEY_FILE = 'api-key.json';
+export const CONFIG_FILE = 'config.json';
+export const SKILL_LOCK_FILE = '.skhema-skill-lock.json';
+// Public API gateway origin. Override via env for staging/preview environments.
+export const API_BASE_URL = process.env.SKHEMA_API_URL ?? 'https://api.skhema.com';
+// Environment variable an unattended CI/agent run sets to supply an API key.
+export const API_KEY_ENV_VAR = 'SKHEMA_API_KEY';
+// Public Skhema MCP server endpoint (Streamable HTTP transport). This is the
+// protocol endpoint AI clients connect to — distinct from mcp.skhema.com (the
+// management dashboard). Auth is per-client browser OAuth on first use, so the
+// CLI only registers the URL; it never injects a credential here.
+// Override via env for staging/preview environments.
+export const MCP_SERVER_URL = process.env.SKHEMA_MCP_URL ?? 'https://mcp-server.skhema.com/mcp';
+// Supabase project configuration.
+// Publishable keys are safe to embed in client-side code (they are the new
+// replacement for the legacy anon key and rely on RLS + server-side auth
+// checks for security). Override via env for staging/preview environments.
+export const SUPABASE_URL = process.env.SKHEMA_SUPABASE_URL ?? 'https://uiybgpcjjrdqmdbarqlx.supabase.co';
+export const SUPABASE_PUBLISHABLE_KEY = process.env.SKHEMA_SUPABASE_PUBLISHABLE_KEY ??
+    'sb_publishable_G9uXii5AYDLK6vUpyaqy3A_-NmdwQF1';

package/dist/lib/contribute/author-resolver.d.ts

@@ -0,0 +1,13 @@
+export interface ResolvedAuthor {
+    authorName: string;
+    authorSlug?: string;
+}
+/**
+ * Resolve author from sysauthElementAuthor for a published element.
+ */
+export declare function resolveElementAuthor(elementId: string, accessToken: string): Promise<ResolvedAuthor | null>;
+/**
+ * Resolve component-level author from the first element in the component.
+ */
+export declare function resolveComponentAuthor(componentId: string, accessToken: string): Promise<ResolvedAuthor | null>;
+//# sourceMappingURL=author-resolver.d.ts.map

package/dist/lib/contribute/author-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"author-resolver.d.ts","sourceRoot":"","sources":["../../../src/lib/contribute/author-resolver.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAqCD;;GAEG;AACH,wBAAsB,oBAAoB,CACxC,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAEhC;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,WAAW,EAAE,MAAM,EACnB,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CA4BhC"}

package/dist/lib/contribute/author-resolver.js

@@ -0,0 +1,63 @@
+import { SUPABASE_PUBLISHABLE_KEY, SUPABASE_URL } from '../config.js';
+async function fetchAuthorForElementId(elementId, accessToken) {
+    const url = new URL(`${SUPABASE_URL}/rest/v1/sysauthElementAuthor`);
+    url.searchParams.set('elementId', `eq.${elementId}`);
+    url.searchParams.set('select', 'authorName,contributorSlug');
+    try {
+        const response = await fetch(url.toString(), {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                apikey: SUPABASE_PUBLISHABLE_KEY,
+                Accept: 'application/json',
+            },
+        });
+        if (!response.ok)
+            return null;
+        const rows = (await response.json());
+        const row = rows[0];
+        if (!row?.authorName)
+            return null;
+        return {
+            authorName: row.authorName,
+            authorSlug: row.contributorSlug ?? undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve author from sysauthElementAuthor for a published element.
+ */
+export async function resolveElementAuthor(elementId, accessToken) {
+    return fetchAuthorForElementId(elementId, accessToken);
+}
+/**
+ * Resolve component-level author from the first element in the component.
+ */
+export async function resolveComponentAuthor(componentId, accessToken) {
+    const junctionUrl = new URL(`${SUPABASE_URL}/rest/v1/sysauthComponentElement`);
+    junctionUrl.searchParams.set('componentId', `eq.${componentId}`);
+    junctionUrl.searchParams.set('select', 'elementId');
+    junctionUrl.searchParams.set('order', 'position.asc');
+    junctionUrl.searchParams.set('limit', '1');
+    try {
+        const junctionResponse = await fetch(junctionUrl.toString(), {
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                apikey: SUPABASE_PUBLISHABLE_KEY,
+                Accept: 'application/json',
+            },
+        });
+        if (!junctionResponse.ok)
+            return null;
+        const junctionRows = (await junctionResponse.json());
+        const firstElementId = junctionRows[0]?.elementId;
+        if (!firstElementId)
+            return null;
+        return fetchAuthorForElementId(firstElementId, accessToken);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/lib/contribute/embed-generator.d.ts

@@ -0,0 +1,4 @@
+import type { GenerateComponentEmbedOptions, GenerateComponentEmbedResult, GenerateEmbedOptions, GenerateEmbedResult } from './types.js';
+export declare function generateEmbed(options: GenerateEmbedOptions): GenerateEmbedResult;
+export declare function generateComponentEmbed(options: GenerateComponentEmbedOptions): GenerateComponentEmbedResult;
+//# sourceMappingURL=embed-generator.d.ts.map

package/dist/lib/contribute/embed-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed-generator.d.ts","sourceRoot":"","sources":["../../../src/lib/contribute/embed-generator.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,6BAA6B,EAC7B,4BAA4B,EAC5B,oBAAoB,EACpB,mBAAmB,EACpB,MAAM,YAAY,CAAA;AAInB,wBAAgB,aAAa,CAC3B,OAAO,EAAE,oBAAoB,GAC5B,mBAAmB,CA8DrB;AAED,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,6BAA6B,GACrC,4BAA4B,CA0G9B"}

package/dist/lib/contribute/embed-generator.js

@@ -0,0 +1,108 @@
+import { COMPONENT_TYPES, ELEMENT_TYPES, SKHEMA_MAPPING, } from './method-schema.js';
+const CDN_URL = 'https://unpkg.com/@skhema/embed';
+export function generateEmbed(options) {
+    const { elementType, contributorId, authorName, authorSlug, content, theme, trackAnalytics, sourceUrl, } = options;
+    if (!contributorId?.trim()) {
+        throw new Error('contributorId is required');
+    }
+    if (!content?.trim()) {
+        throw new Error('content is required');
+    }
+    const validTypes = Object.values(ELEMENT_TYPES).map((t) => t.value);
+    if (!validTypes.includes(elementType)) {
+        throw new Error(`Invalid element type "${elementType}". Valid types: ${validTypes.join(', ')}`);
+    }
+    const attributes = {
+        'element-type': elementType,
+        'contributor-id': contributorId,
+    };
+    if (authorName) {
+        attributes['author-name'] = authorName;
+    }
+    if (authorSlug) {
+        attributes['author-slug'] = authorSlug;
+    }
+    if (theme && theme !== 'auto') {
+        attributes['theme'] = theme;
+    }
+    if (trackAnalytics === false) {
+        attributes['track-analytics'] = 'false';
+    }
+    if (sourceUrl) {
+        attributes['source-url'] = sourceUrl;
+    }
+    const attrLines = Object.entries(attributes)
+        .map(([key, value]) => `  ${key}="${value}"`)
+        .join('\n');
+    const snippet = `<script src="${CDN_URL}"></script>
+<skhema-element
+${attrLines}>
+  ${content}
+</skhema-element>`;
+    return { snippet, cdnUrl: CDN_URL, attributes };
+}
+export function generateComponentEmbed(options) {
+    const { componentType, contributorId, authorName, authorSlug, elements, title, theme, trackAnalytics, sourceUrl, } = options;
+    if (!contributorId?.trim()) {
+        throw new Error('contributorId is required');
+    }
+    if (!elements || elements.length === 0) {
+        throw new Error('At least one element is required');
+    }
+    const validComponentTypes = Object.values(COMPONENT_TYPES).map((t) => t.value);
+    if (!validComponentTypes.includes(componentType)) {
+        throw new Error(`Invalid component type "${componentType}". Valid types: ${validComponentTypes.join(', ')}`);
+    }
+    const validElementTypes = SKHEMA_MAPPING.elementFlow[componentType];
+    if (validElementTypes) {
+        const validValues = validElementTypes.map((t) => t.value);
+        for (const element of elements) {
+            if (!validValues.includes(element.elementType)) {
+                throw new Error(`Invalid element type "${element.elementType}" for component "${componentType}". Valid types: ${validValues.join(', ')}`);
+            }
+            if (!element.content?.trim()) {
+                throw new Error(`Element of type "${element.elementType}" has empty content`);
+            }
+        }
+    }
+    const attributes = {
+        'component-type': componentType,
+        'contributor-id': contributorId,
+    };
+    if (authorName) {
+        attributes['author-name'] = authorName;
+    }
+    if (authorSlug) {
+        attributes['author-slug'] = authorSlug;
+    }
+    if (title) {
+        attributes['title'] = title;
+    }
+    if (theme && theme !== 'auto') {
+        attributes['theme'] = theme;
+    }
+    if (trackAnalytics === false) {
+        attributes['track-analytics'] = 'false';
+    }
+    if (sourceUrl) {
+        attributes['source-url'] = sourceUrl;
+    }
+    const componentAttrLines = Object.entries(attributes)
+        .map(([key, value]) => `  ${key}="${value}"`)
+        .join('\n');
+    const elementSnippets = elements
+        .map((element) => {
+        const elementAttrLines = [
+            `    element-type="${element.elementType}"`,
+            `    contributor-id="${contributorId}"`,
+        ].join('\n');
+        return `  <skhema-element\n${elementAttrLines}>\n    ${element.content}\n  </skhema-element>`;
+    })
+        .join('\n');
+    const snippet = `<script src="${CDN_URL}"></script>
+<skhema-component
+${componentAttrLines}>
+${elementSnippets}
+</skhema-component>`;
+    return { snippet, cdnUrl: CDN_URL, attributes, elementCount: elements.length };
+}

package/dist/lib/contribute/link-generator.d.ts

@@ -0,0 +1,11 @@
+import type { GenerateComponentLinkOptions, GenerateComponentLinkResult, GenerateLinkOptions, GenerateLinkResult, PublishComponentShareLinkOptions, PublishComponentShareLinkResult, PublishShareLinkOptions, PublishShareLinkResult } from './types.js';
+export declare function generateContentHash(content: string): string;
+export declare function generateSaveElementLink(options: GenerateLinkOptions): GenerateLinkResult;
+export declare function generateComponentHash(elements: Array<{
+    elementType: string;
+    content: string;
+}>): string;
+export declare function generateSaveComponentLink(options: GenerateComponentLinkOptions): GenerateComponentLinkResult;
+export declare function publishAndGenerateElementShareLink(options: PublishShareLinkOptions): Promise<PublishShareLinkResult>;
+export declare function publishAndGenerateComponentShareLink(options: PublishComponentShareLinkOptions): Promise<PublishComponentShareLinkResult>;
+//# sourceMappingURL=link-generator.d.ts.map

package/dist/lib/contribute/link-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"link-generator.d.ts","sourceRoot":"","sources":["../../../src/lib/contribute/link-generator.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,4BAA4B,EAC5B,2BAA2B,EAC3B,mBAAmB,EACnB,kBAAkB,EAClB,gCAAgC,EAChC,+BAA+B,EAC/B,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,YAAY,CAAA;AAInB,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAS3D;AAED,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,mBAAmB,GAC3B,kBAAkB,CAmBpB;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,KAAK,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,GACxD,MAAM,CASR;AAED,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,4BAA4B,GACpC,2BAA2B,CAyB7B;AAED,wBAAsB,kCAAkC,CACtD,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,sBAAsB,CAAC,CA6BjC;AAED,wBAAsB,oCAAoC,CACxD,OAAO,EAAE,gCAAgC,GACxC,OAAO,CAAC,+BAA+B,CAAC,CAgC1C"}

package/dist/lib/contribute/link-generator.js

@@ -0,0 +1,119 @@
+import { SUPABASE_PUBLISHABLE_KEY, SUPABASE_URL } from '../config.js';
+const EMBED_MANAGE_URL = `${SUPABASE_URL}/functions/v1/embed-manage`;
+export function generateContentHash(content) {
+    let hash = 0;
+    const cleanContent = content.trim().substring(0, 200);
+    for (let i = 0; i < cleanContent.length; i++) {
+        const char = cleanContent.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+    }
+    return Math.abs(hash).toString(36).substring(0, 12);
+}
+export function generateSaveElementLink(options) {
+    const contentHash = generateContentHash(options.content);
+    const sourceUrl = options.sourceUrl
+        ? encodeURIComponent(options.sourceUrl)
+        : '';
+    const timestamp = Date.now();
+    const params = new URLSearchParams({
+        source: sourceUrl,
+        t: timestamp.toString(),
+        utm_source: options.utmSource || 'web_component',
+        utm_medium: options.utmMedium || 'embedded',
+        utm_campaign: options.utmCampaign || options.elementType,
+        utm_content: options.contributorId,
+    });
+    const url = `https://app.skhema.com/save?type=contributor&contributor_id=${options.contributorId}&element_type=${options.elementType}&content_hash=${contentHash}&${params.toString()}`;
+    return { url, contentHash };
+}
+export function generateComponentHash(elements) {
+    const sorted = [...elements].sort((a, b) => {
+        const typeCompare = a.elementType.localeCompare(b.elementType);
+        if (typeCompare !== 0)
+            return typeCompare;
+        return a.content.localeCompare(b.content);
+    });
+    const combined = sorted.map((e) => `${e.elementType}:${e.content}`).join('|');
+    return generateContentHash(combined);
+}
+export function generateSaveComponentLink(options) {
+    const componentHash = generateComponentHash(options.elements);
+    const sourceUrl = options.sourceUrl
+        ? encodeURIComponent(options.sourceUrl)
+        : '';
+    const timestamp = Date.now();
+    const params = new URLSearchParams({
+        source: sourceUrl,
+        t: timestamp.toString(),
+        utm_source: options.utmSource || 'web_component',
+        utm_medium: options.utmMedium || 'embedded',
+        utm_campaign: options.utmCampaign || options.componentType,
+        utm_content: options.contributorId,
+    });
+    let url = `https://app.skhema.com/save?type=component&component_type=${options.componentType}&component_hash=${componentHash}&contributor_id=${options.contributorId}`;
+    if (options.title) {
+        url += `&title=${encodeURIComponent(options.title)}`;
+    }
+    url += `&${params.toString()}`;
+    return { url, componentHash };
+}
+export async function publishAndGenerateElementShareLink(options) {
+    const response = await fetch(EMBED_MANAGE_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            apikey: SUPABASE_PUBLISHABLE_KEY,
+            Authorization: `Bearer ${options.accessToken}`,
+        },
+        body: JSON.stringify({
+            action: 'publish-for-share',
+            contributor_id: options.contributorId,
+            element_type: options.elementType,
+            content: options.content,
+        }),
+    });
+    if (!response.ok) {
+        const error = await response
+            .json()
+            .catch(() => ({ error: 'Unknown error' }));
+        throw new Error(error.error || `Publish failed: ${response.status}`);
+    }
+    const data = await response.json();
+    return {
+        shareUrl: `https://skhema.com/embed/e/${data.id}`,
+        elementId: data.id,
+        contentHash: data.content_hash,
+    };
+}
+export async function publishAndGenerateComponentShareLink(options) {
+    const response = await fetch(EMBED_MANAGE_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            apikey: SUPABASE_PUBLISHABLE_KEY,
+            Authorization: `Bearer ${options.accessToken}`,
+        },
+        body: JSON.stringify({
+            action: 'publish-component-for-share',
+            contributor_id: options.contributorId,
+            component_type: options.componentType,
+            title: options.title || null,
+            elements: options.elements.map((el) => ({
+                element_type: el.elementType,
+                content: el.content,
+            })),
+        }),
+    });
+    if (!response.ok) {
+        const error = await response
+            .json()
+            .catch(() => ({ error: 'Unknown error' }));
+        throw new Error(error.error || `Publish failed: ${response.status}`);
+    }
+    const data = await response.json();
+    return {
+        shareUrl: `https://skhema.com/embed/c/${data.id}`,
+        componentId: data.id,
+    };
+}

package/dist/lib/contribute/method-schema.d.ts

@@ -0,0 +1,239 @@
+/**
+ * Vendored from @skhema/types (src/schema/{elements,components,mapping}.ts).
+ *
+ * @skhema/types is a restricted npm package; @skhema/cli is public, so it must
+ * not depend on it at install time. This is the public method vocabulary (it
+ * renders verbatim in public embeds) — keep it in sync with @skhema/types when
+ * the method schema changes.
+ */
+export declare const ELEMENT_TYPES: {
+    readonly KEY_CHALLENGE: {
+        readonly value: "key_challenge";
+        readonly label: "Key Challenge";
+        readonly acronym: "CHL";
+    };
+    readonly SUPPORTING_FACT: {
+        readonly value: "supporting_fact";
+        readonly label: "Supporting Fact";
+        readonly acronym: "FCT";
+    };
+    readonly IMPACT: {
+        readonly value: "impact";
+        readonly label: "Impact";
+        readonly acronym: "IMP";
+    };
+    readonly GUIDING_POLICY: {
+        readonly value: "guiding_policy";
+        readonly label: "Guiding Policy";
+        readonly acronym: "POL";
+    };
+    readonly COMPETITOR_MOVE: {
+        readonly value: "competitor_move";
+        readonly label: "Competitor Move";
+        readonly acronym: "CMV";
+    };
+    readonly SCOPE: {
+        readonly value: "scope";
+        readonly label: "Scope";
+        readonly acronym: "SCP";
+    };
+    readonly CONSTRAINT: {
+        readonly value: "constraint";
+        readonly label: "Constraint";
+        readonly acronym: "CST";
+    };
+    readonly SOLUTION: {
+        readonly value: "solution";
+        readonly label: "Solution";
+        readonly acronym: "SOL";
+    };
+    readonly ASSUMPTION_HYPOTHESIS: {
+        readonly value: "assumption_hypothesis";
+        readonly label: "Assumption Hypothesis";
+        readonly acronym: "HYP";
+    };
+    readonly EXPERIMENT: {
+        readonly value: "experiment";
+        readonly label: "Experiment";
+        readonly acronym: "EXP";
+    };
+    readonly ACTION: {
+        readonly value: "action";
+        readonly label: "Action";
+        readonly acronym: "ACT";
+    };
+    readonly INVESTMENT: {
+        readonly value: "investment";
+        readonly label: "Investment";
+        readonly acronym: "INV";
+    };
+    readonly ESTIMATE: {
+        readonly value: "estimate";
+        readonly label: "Estimate";
+        readonly acronym: "EST";
+    };
+    readonly BASELINE: {
+        readonly value: "baseline";
+        readonly label: "Baseline";
+        readonly acronym: "BSL";
+    };
+    readonly OUTCOME: {
+        readonly value: "outcome";
+        readonly label: "Outcome";
+        readonly acronym: "OCM";
+    };
+    readonly PERFORMANCE_VARIABLE: {
+        readonly value: "performance_variable";
+        readonly label: "Performance Variable";
+        readonly acronym: "VAR";
+    };
+    readonly CAPABILITY: {
+        readonly value: "capability";
+        readonly label: "Capability";
+        readonly acronym: "CAP";
+    };
+    readonly SYSTEM: {
+        readonly value: "system";
+        readonly label: "System";
+        readonly acronym: "SYS";
+    };
+    readonly PRINCIPLE: {
+        readonly value: "principle";
+        readonly label: "Principle";
+        readonly acronym: "PRN";
+    };
+};
+export declare const COMPONENT_TYPES: {
+    readonly DIAGNOSIS: {
+        readonly value: "diagnosis";
+        readonly label: "Diagnosis";
+        readonly acronym: "BD";
+    };
+    readonly METHOD: {
+        readonly value: "method";
+        readonly label: "Method & Positioning";
+        readonly acronym: "MP";
+    };
+    readonly INITIATIVES: {
+        readonly value: "initiatives";
+        readonly label: "Portfolio of Initiatives";
+        readonly acronym: "PI";
+    };
+    readonly MEASURES: {
+        readonly value: "measures";
+        readonly label: "Measures";
+        readonly acronym: "M";
+    };
+    readonly SUPPORT: {
+        readonly value: "support";
+        readonly label: "Support Structures";
+        readonly acronym: "SS";
+    };
+};
+export declare const SKHEMA_MAPPING: {
+    readonly componentFlow: readonly [{
+        readonly value: "diagnosis";
+        readonly label: "Diagnosis";
+        readonly acronym: "BD";
+    }, {
+        readonly value: "method";
+        readonly label: "Method & Positioning";
+        readonly acronym: "MP";
+    }, {
+        readonly value: "initiatives";
+        readonly label: "Portfolio of Initiatives";
+        readonly acronym: "PI";
+    }, {
+        readonly value: "measures";
+        readonly label: "Measures";
+        readonly acronym: "M";
+    }, {
+        readonly value: "support";
+        readonly label: "Support Structures";
+        readonly acronym: "SS";
+    }];
+    readonly elementFlow: {
+        readonly diagnosis: readonly [{
+            readonly value: "key_challenge";
+            readonly label: "Key Challenge";
+            readonly acronym: "CHL";
+        }, {
+            readonly value: "supporting_fact";
+            readonly label: "Supporting Fact";
+            readonly acronym: "FCT";
+        }, {
+            readonly value: "impact";
+            readonly label: "Impact";
+            readonly acronym: "IMP";
+        }];
+        readonly method: readonly [{
+            readonly value: "guiding_policy";
+            readonly label: "Guiding Policy";
+            readonly acronym: "POL";
+        }, {
+            readonly value: "competitor_move";
+            readonly label: "Competitor Move";
+            readonly acronym: "CMV";
+        }, {
+            readonly value: "scope";
+            readonly label: "Scope";
+            readonly acronym: "SCP";
+        }, {
+            readonly value: "constraint";
+            readonly label: "Constraint";
+            readonly acronym: "CST";
+        }];
+        readonly initiatives: readonly [{
+            readonly value: "solution";
+            readonly label: "Solution";
+            readonly acronym: "SOL";
+        }, {
+            readonly value: "assumption_hypothesis";
+            readonly label: "Assumption Hypothesis";
+            readonly acronym: "HYP";
+        }, {
+            readonly value: "experiment";
+            readonly label: "Experiment";
+            readonly acronym: "EXP";
+        }, {
+            readonly value: "action";
+            readonly label: "Action";
+            readonly acronym: "ACT";
+        }, {
+            readonly value: "estimate";
+            readonly label: "Estimate";
+            readonly acronym: "EST";
+        }, {
+            readonly value: "investment";
+            readonly label: "Investment";
+            readonly acronym: "INV";
+        }];
+        readonly measures: readonly [{
+            readonly value: "baseline";
+            readonly label: "Baseline";
+            readonly acronym: "BSL";
+        }, {
+            readonly value: "outcome";
+            readonly label: "Outcome";
+            readonly acronym: "OCM";
+        }, {
+            readonly value: "performance_variable";
+            readonly label: "Performance Variable";
+            readonly acronym: "VAR";
+        }];
+        readonly support: readonly [{
+            readonly value: "capability";
+            readonly label: "Capability";
+            readonly acronym: "CAP";
+        }, {
+            readonly value: "system";
+            readonly label: "System";
+            readonly acronym: "SYS";
+        }, {
+            readonly value: "principle";
+            readonly label: "Principle";
+            readonly acronym: "PRN";
+        }];
+    };
+};
+//# sourceMappingURL=method-schema.d.ts.map

package/dist/lib/contribute/method-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/contribute/method-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgGhB,CAAA;AAEV,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BlB,CAAA;AAEV,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwCjB,CAAA"}