salesforce-metadata-mcp 2.2.0 → 2.3.0

package/dist/services/salesforce.js

@@ -2653,4 +2653,671 @@ export async function setExperienceSiteBranding(auth, params) {
         return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
     }
 }
+// ─── v2.3.0 OmniStudio Service Functions ─────────────────────────────────────
+function buildFlexCardDefinition(params) {
+    return {
+        name: params.cardName,
+        sObjectType: params.objectApiName ?? "",
+        dataSource: params.dataSourceType !== "None" ? {
+            type: params.dataSourceType,
+            value: params.dataSourceName ?? "",
+        } : null,
+        elements: (params.fields ?? []).map(f => ({
+            type: "text",
+            name: `field_${f.fieldName}`,
+            label: f.label,
+            fieldName: f.fieldName,
+            dataType: f.type ?? "Text",
+        })),
+        actions: (params.actions ?? []).map(a => ({
+            type: a.type,
+            label: a.label,
+            target: a.target,
+        })),
+        states: (params.states ?? [{ name: "Default", conditionType: "ALL", conditions: [] }]).map(s => ({
+            name: s.name,
+            conditionType: s.conditionType,
+            conditions: s.conditions ?? [],
+        })),
+    };
+}
+export async function createFlexCard(auth, params) {
+    try {
+        const definition = buildFlexCardDefinition(params);
+        const xml = `<met:metadata xsi:type="met:OmniUiCard" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.cardName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    <met:omniUiCardType>Child</met:omniUiCardType>
+    <met:versionNumber>1</met:versionNumber>
+    <met:isActive>false</met:isActive>
+    <met:omniUiCardDefinition>${x(JSON.stringify(definition))}</met:omniUiCardDefinition>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function updateFlexCard(auth, params) {
+    try {
+        const existing = await readMetadataItem(auth, "OmniUiCard", params.cardName);
+        if (!existing.success) return existing;
+        const defMatch = existing.rawXml.match(/<omniUiCardDefinition[^>]*>([\s\S]*?)<\/omniUiCardDefinition>/i);
+        let definition = {};
+        if (defMatch) {
+            try { definition = JSON.parse(defMatch[1].replace(/&amp;/g,"&").replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&quot;/g,'"').replace(/&apos;/g,"'")); }
+            catch { /* use empty definition */ }
+        }
+        const merged = {
+            ...definition,
+            ...(params.dataSourceType ? { dataSource: { type: params.dataSourceType, value: params.dataSourceName ?? "" } } : {}),
+            ...(params.fields ? { elements: params.fields.map(f => ({ type: "text", name: `field_${f.fieldName}`, label: f.label, fieldName: f.fieldName })) } : {}),
+            ...(params.actions ? { actions: params.actions } : {}),
+            ...(params.states ? { states: params.states } : {}),
+        };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const currentLabel = labelMatch?.[1] ?? params.cardName;
+        const xml = `<met:metadata xsi:type="met:OmniUiCard" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.cardName)}</met:fullName>
+    <met:masterLabel>${x(params.label ?? currentLabel)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    <met:omniUiCardType>Child</met:omniUiCardType>
+    <met:isActive>false</met:isActive>
+    <met:omniUiCardDefinition>${x(JSON.stringify(merged))}</met:omniUiCardDefinition>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function activateFlexCard(auth, params) {
+    try {
+        const existing = await readMetadataItem(auth, "OmniUiCard", params.cardName);
+        if (!existing.success) return { success: false, message: `FlexCard '${params.cardName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const defMatch = existing.rawXml.match(/<omniUiCardDefinition[^>]*>([\s\S]*?)<\/omniUiCardDefinition>/i);
+        const typeMatch = existing.rawXml.match(/<omniUiCardType[^>]*>([\s\S]*?)<\/omniUiCardType>/i);
+        const xml = `<met:metadata xsi:type="met:OmniUiCard" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.cardName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? params.cardName}</met:masterLabel>
+    <met:omniUiCardType>${typeMatch?.[1] ?? "Child"}</met:omniUiCardType>
+    <met:isActive>true</met:isActive>
+    ${defMatch ? `<met:omniUiCardDefinition>${defMatch[1]}</met:omniUiCardDefinition>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getFlexCard(auth, params) {
+    try {
+        const result = await readMetadataItem(auth, "OmniUiCard", params.cardName);
+        if (!result.success) return result;
+        const labelMatch = result.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const isActiveMatch = result.rawXml.match(/<isActive[^>]*>([\s\S]*?)<\/isActive>/i);
+        const defMatch = result.rawXml.match(/<omniUiCardDefinition[^>]*>([\s\S]*?)<\/omniUiCardDefinition>/i);
+        let definition = null;
+        if (defMatch) {
+            try { definition = JSON.parse(defMatch[1].replace(/&amp;/g,"&").replace(/&lt;/g,"<").replace(/&gt;/g,">").replace(/&quot;/g,'"').replace(/&apos;/g,"'")); }
+            catch { definition = defMatch[1]; }
+        }
+        return { success: true, cardName: params.cardName, label: labelMatch?.[1] ?? "", isActive: isActiveMatch?.[1] === "true", definition, message: `FlexCard '${params.cardName}' retrieved.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createOmniScript(auth, params) {
+    try {
+        const fullName = `${params.type}_${params.subType}_${params.language}`;
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:type>${x(params.type)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>${x(params.language)}</met:language>
+    <met:omniProcessType>OmniScript</met:omniProcessType>
+    <met:isActive>false</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>${params.isLwcEnabled !== false ? "true" : "false"}</met:isLwcEnabled>
+    <met:isOmniScriptEmbeddable>${params.isOmniScriptEmbeddable ? "true" : "false"}</met:isOmniScriptEmbeddable>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function updateOmniScript(auth, params) {
+    try {
+        const fullName = `${params.type}_${params.subType}_${params.language}`;
+        const existing = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!existing.success) return { success: false, message: `OmniScript '${fullName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? fullName}</met:masterLabel>
+    <met:type>${x(params.type)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>${x(params.language)}</met:language>
+    <met:omniProcessType>OmniScript</met:omniProcessType>
+    <met:isActive>false</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    ${params.isLwcEnabled !== undefined ? `<met:isLwcEnabled>${params.isLwcEnabled}</met:isLwcEnabled>` : ""}
+    ${params.isOmniScriptEmbeddable !== undefined ? `<met:isOmniScriptEmbeddable>${params.isOmniScriptEmbeddable}</met:isOmniScriptEmbeddable>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function activateOmniScript(auth, params) {
+    try {
+        const fullName = `${params.type}_${params.subType}_${params.language}`;
+        const existing = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!existing.success) return { success: false, message: `OmniScript '${fullName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? fullName}</met:masterLabel>
+    <met:type>${x(params.type)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>${x(params.language)}</met:language>
+    <met:omniProcessType>OmniScript</met:omniProcessType>
+    <met:isActive>true</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>true</met:isLwcEnabled>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getOmniScript(auth, params) {
+    try {
+        const fullName = `${params.type}_${params.subType}_${params.language}`;
+        const result = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!result.success) return result;
+        const get = (tag) => result.rawXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"))?.[1] ?? "";
+        return {
+            success: true,
+            fullName,
+            type: get("type"),
+            subType: get("subType"),
+            language: get("language"),
+            isActive: get("isActive") === "true",
+            isLwcEnabled: get("isLwcEnabled") === "true",
+            message: `OmniScript '${fullName}' retrieved.`,
+        };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createDataRaptor(auth, params) {
+    try {
+        const mapItemsXml = (params.fields ?? []).map((f, i) => {
+            const isJSON = f.sourceField.startsWith("$.");
+            return `
+    <met:mapItems>
+        <met:index>${i}</met:index>
+        <met:objectName>${x(params.objectApiName ?? "")}</met:objectName>
+        <met:field>${x(isJSON ? "" : f.sourceField)}</met:field>
+        <met:JSONPath>${x(isJSON ? f.sourceField : "")}</met:JSONPath>
+        <met:targetField>${x(f.targetField)}</met:targetField>
+        <met:dataType>${x(f.dataType ?? "String")}</met:dataType>
+        ${f.formula ? `<met:formula>${x(f.formula)}</met:formula>` : ""}
+        <met:operationType>First</met:operationType>
+        <met:sourceObjectName>${x(params.objectApiName ?? "")}</met:sourceObjectName>
+    </met:mapItems>`;
+        }).join("");
+        const xml = `<met:metadata xsi:type="met:DataRaptorInterface" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.dataRaptorName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:interfaceType>${x(params.interfaceType)}</met:interfaceType>
+    ${params.objectApiName ? `<met:objectName>${x(params.objectApiName)}</met:objectName>` : ""}
+    ${params.filterCriteria ? `<met:filterCriteria>${x(params.filterCriteria)}</met:filterCriteria>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${mapItemsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getDataRaptor(auth, params) {
+    try {
+        const result = await readMetadataItem(auth, "DataRaptorInterface", params.dataRaptorName);
+        if (!result.success) return result;
+        const get = (tag) => result.rawXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"))?.[1]?.trim() ?? "";
+        const items = [...result.rawXml.matchAll(/<mapItems>([\s\S]*?)<\/mapItems>/gi)].map(m => {
+            const inner = m[1];
+            const gi = (t) => inner.match(new RegExp(`<${t}[^>]*>([\\s\\S]*?)<\\/${t}>`, "i"))?.[1]?.trim() ?? "";
+            return { field: gi("field"), jsonPath: gi("JSONPath"), targetField: gi("targetField"), dataType: gi("dataType") };
+        });
+        return { success: true, dataRaptorName: params.dataRaptorName, label: get("masterLabel"), interfaceType: get("interfaceType"), objectName: get("objectName"), filterCriteria: get("filterCriteria"), fieldMappings: items, message: `DataRaptor '${params.dataRaptorName}' retrieved.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createIntegrationProcedure(auth, params) {
+    try {
+        const fullName = `${params.procedureName}_${params.subType}`;
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:type>${x(params.procedureName)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>English</met:language>
+    <met:omniProcessType>IntegrationProcedure</met:omniProcessType>
+    <met:isActive>${params.isActive ? "true" : "false"}</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>false</met:isLwcEnabled>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function updateIntegrationProcedure(auth, params) {
+    try {
+        const fullName = `${params.procedureName}_${params.subType}`;
+        const existing = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!existing.success) return { success: false, message: `Integration Procedure '${fullName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? fullName}</met:masterLabel>
+    <met:type>${x(params.procedureName)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>English</met:language>
+    <met:omniProcessType>IntegrationProcedure</met:omniProcessType>
+    ${params.isActive !== undefined ? `<met:isActive>${params.isActive}</met:isActive>` : "<met:isActive>false</met:isActive>"}
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>false</met:isLwcEnabled>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function activateIntegrationProcedure(auth, params) {
+    try {
+        const fullName = `${params.procedureName}_${params.subType}`;
+        const existing = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!existing.success) return { success: false, message: `Integration Procedure '${fullName}' not found.` };
+        const labelMatch = existing.rawXml.match(/<masterLabel[^>]*>([\s\S]*?)<\/masterLabel>/i);
+        const xml = `<met:metadata xsi:type="met:OmniScript" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(fullName)}</met:fullName>
+    <met:masterLabel>${labelMatch?.[1] ?? fullName}</met:masterLabel>
+    <met:type>${x(params.procedureName)}</met:type>
+    <met:subType>${x(params.subType)}</met:subType>
+    <met:language>English</met:language>
+    <met:omniProcessType>IntegrationProcedure</met:omniProcessType>
+    <met:isActive>true</met:isActive>
+    <met:isInternal>false</met:isInternal>
+    <met:isLwcEnabled>false</met:isLwcEnabled>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function getIntegrationProcedure(auth, params) {
+    try {
+        const fullName = `${params.procedureName}_${params.subType}`;
+        const result = await readMetadataItem(auth, "OmniScript", fullName);
+        if (!result.success) return result;
+        const get = (tag) => result.rawXml.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, "i"))?.[1]?.trim() ?? "";
+        return { success: true, fullName, type: get("type"), subType: get("subType"), isActive: get("isActive") === "true", description: get("description"), message: `Integration Procedure '${fullName}' retrieved.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createCalculationMatrix(auth, params) {
+    try {
+        const inputVarsXml = params.inputVariables.map(v => `
+    <met:inputVariables>
+        <met:dataType>${x(v.dataType ?? "String")}</met:dataType>
+        <met:name>${x(v.name)}</met:name>
+    </met:inputVariables>`).join("");
+        const outputVarsXml = params.outputVariables.map(v => `
+    <met:outputVariables>
+        <met:dataType>${x(v.dataType ?? "String")}</met:dataType>
+        <met:name>${x(v.name)}</met:name>
+    </met:outputVariables>`).join("");
+        const rowsXml = (params.rows ?? []).map((row, ri) => {
+            const cellsXml = Object.entries(row).map(([k, v]) => `
+        <met:cells>
+            <met:variableName>${x(k)}</met:variableName>
+            <met:value>${x(v)}</met:value>
+        </met:cells>`).join("");
+            return `
+    <met:matrixRows>
+        <met:rowNumber>${ri + 1}</met:rowNumber>
+        ${cellsXml}
+    </met:matrixRows>`;
+        }).join("");
+        const xml = `<met:metadata xsi:type="met:CalculationMatrix" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.matrixName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${inputVarsXml}
+    ${outputVarsXml}
+    ${rowsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createCalculationProcedure(auth, params) {
+    try {
+        const stepsXml = (params.steps ?? []).map((s, i) => `
+    <met:calculationProcedureSteps>
+        <met:stepNumber>${i + 1}</met:stepNumber>
+        <met:developerName>${x(s.name)}</met:developerName>
+        <met:stepType>${x(s.type ?? "Expression")}</met:stepType>
+        ${s.matrixName ? `<met:calculationMatrix>${x(s.matrixName)}</met:calculationMatrix>` : ""}
+        ${s.expression ? `<met:expression>${x(s.expression)}</met:expression>` : ""}
+        ${s.inputMap ? Object.entries(s.inputMap).map(([k,v]) => `<met:inputParameters><met:name>${x(k)}</met:name><met:value>${x(v)}</met:value></met:inputParameters>`).join("") : ""}
+        ${s.outputMap ? Object.entries(s.outputMap).map(([k,v]) => `<met:outputParameters><met:name>${x(k)}</met:name><met:value>${x(v)}</met:value></met:outputParameters>`).join("") : ""}
+    </met:calculationProcedureSteps>`).join("");
+        const xml = `<met:metadata xsi:type="met:CalculationProcedure" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.procedureName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${stepsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+// ─── v2.3.0 OmniChannel Service Functions ────────────────────────────────────
+export async function createServiceChannel(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:ServiceChannel" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.channelName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:relatedEntity>${x(params.relatedObjectApiName ?? (params.channelType === "Case" ? "Case" : params.channelType === "Chat" ? "LiveChatTranscript" : params.channelType === "Email" ? "EmailMessage" : "Case"))}</met:relatedEntity>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createRoutingConfiguration(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:RoutingConfiguration" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.configName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:routingModel>${x(params.routingModel)}</met:routingModel>
+    <met:routingPriority>${params.priority ?? 1}</met:routingPriority>
+    ${params.unitType === "Items" ? `<met:capacityWeight>${params.capacity ?? 1}</met:capacityWeight>` : `<met:capacityPercentage>${params.capacity ?? 100}</met:capacityPercentage>`}
+    <met:unitType>${x(params.unitType ?? "Percentage")}</met:unitType>
+    ${params.pushTimeout !== undefined ? `<met:pushTimeout>${params.pushTimeout}</met:pushTimeout>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createQueueRoutingConfig(auth, params) {
+    try {
+        // Link a routing config to a queue by updating the Queue metadata
+        const readResult = await readMetadataItem(auth, "Queue", params.queueDeveloperName);
+        if (!readResult.success) return { success: false, message: `Queue '${params.queueDeveloperName}' not found.` };
+        const labelMatch = readResult.rawXml.match(/<label[^>]*>([\s\S]*?)<\/label>/i);
+        const emailMatch = readResult.rawXml.match(/<email[^>]*>([\s\S]*?)<\/email>/i);
+        const xml = `<met:metadata xsi:type="met:Queue" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.queueDeveloperName)}</met:fullName>
+    <met:label>${labelMatch?.[1] ?? params.queueDeveloperName}</met:label>
+    ${emailMatch?.[1] ? `<met:email>${emailMatch[1]}</met:email>` : ""}
+    <met:routingConfiguration>${x(params.routingConfigName)}</met:routingConfiguration>
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createPresenceConfiguration(auth, params) {
+    try {
+        const channelsXml = (params.serviceChannels ?? []).map(ch => `
+    <met:presenceConfigAssignments>
+        <met:serviceChannel>${x(ch.channelName)}</met:serviceChannel>
+        ${ch.capacity ? `<met:capacity>${ch.capacity}</met:capacity>` : ""}
+    </met:presenceConfigAssignments>`).join("");
+        const xml = `<met:metadata xsi:type="met:PresenceUserConfig" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.configName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:capacity>${params.capacity ?? 10}</met:capacity>
+    <met:allowAgentsToChangeSatus>${params.allowAgentsToChangeStatus !== false ? "true" : "false"}</met:allowAgentsToChangeSatus>
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+    ${channelsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createPresenceStatus(auth, params) {
+    try {
+        const channelsXml = (params.serviceChannels ?? []).map(ch => `
+    <met:serviceChannels>
+        <met:channel>${x(ch)}</met:channel>
+    </met:serviceChannels>`).join("");
+        const xml = `<met:metadata xsi:type="met:ServicePresenceStatus" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.statusName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:statusType>${x(params.statusType ?? "Online")}</met:statusType>
+    ${channelsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function assignPresenceStatus(auth, params) {
+    try {
+        const results = [];
+        for (const profileName of (params.profiles ?? [])) {
+            const xml = `<met:metadata xsi:type="met:Profile" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(profileName)}</met:fullName>
+    <met:servicePresenceStatusAccesses>
+        <met:servicePresenceStatus>${x(params.statusName)}</met:servicePresenceStatus>
+        <met:visible>true</met:visible>
+    </met:servicePresenceStatusAccesses>
+</met:metadata>`;
+            results.push(await upsertMetadata(auth, xml));
+        }
+        for (const psName of (params.permissionSets ?? [])) {
+            const xml = `<met:metadata xsi:type="met:PermissionSet" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(psName)}</met:fullName>
+    <met:servicePresenceStatusAccesses>
+        <met:servicePresenceStatus>${x(params.statusName)}</met:servicePresenceStatus>
+        <met:visible>true</met:visible>
+    </met:servicePresenceStatusAccesses>
+</met:metadata>`;
+            results.push(await upsertMetadata(auth, xml));
+        }
+        if (!results.length) return { success: false, message: "Provide at least one profile or permissionSet." };
+        const allOk = results.every(r => r.success);
+        return { success: allOk, message: allOk ? `Presence status '${params.statusName}' assigned to ${results.length} profile(s)/permission set(s).` : results.filter(r => !r.success).map(r => r.message).join("; ") };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createSkill(auth, params) {
+    try {
+        // Skill is a REST SObject in Service Cloud
+        const client = createClient(auth);
+        const resp = await client.post("/sobjects/Skill", { MasterLabel: params.label, DeveloperName: params.skillName, Description: params.description ?? "" });
+        return { success: true, fullName: resp.data.id, created: true, message: `Skill '${params.skillName}' created with ID ${resp.data.id}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function assignSkillToAgent(auth, params) {
+    try {
+        const client = createClient(auth);
+        // Get skill ID
+        const skillResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM Skill WHERE DeveloperName = '${params.skillName.replace(/'/g,"\\'")}' LIMIT 1`)}`);
+        const skillId = skillResp.data.records?.[0]?.Id;
+        if (!skillId) return { success: false, message: `Skill '${params.skillName}' not found.` };
+        // Get user ID
+        const userResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM User WHERE Username = '${params.username.replace(/'/g,"\\'")}' LIMIT 1`)}`);
+        const userId = userResp.data.records?.[0]?.Id;
+        if (!userId) return { success: false, message: `User '${params.username}' not found.` };
+        // Get or create ServiceResource
+        const srResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM ServiceResource WHERE RelatedRecordId = '${userId}' LIMIT 1`)}`);
+        let srId = srResp.data.records?.[0]?.Id;
+        if (!srId) {
+            const newSr = await client.post("/sobjects/ServiceResource", { RelatedRecordId: userId, Name: params.username, ResourceType: "T", IsActive: true });
+            srId = newSr.data.id;
+        }
+        // Create ServiceResourceSkill
+        const resp = await client.post("/sobjects/ServiceResourceSkill", { ServiceResourceId: srId, SkillId: skillId, SkillLevel: params.skillLevel ?? 5, EffectiveStartDate: new Date().toISOString().slice(0, 10) });
+        return { success: true, fullName: resp.data.id, created: true, message: `Skill '${params.skillName}' assigned to '${params.username}' with level ${params.skillLevel ?? 5}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createServiceTerritory(auth, params) {
+    try {
+        const client = createClient(auth);
+        const payload = { Name: params.label, IsActive: params.isActive !== false };
+        if (params.street) payload["Street"] = params.street;
+        if (params.city) payload["City"] = params.city;
+        if (params.state) payload["State"] = params.state;
+        if (params.country) payload["Country"] = params.country;
+        if (params.postalCode) payload["PostalCode"] = params.postalCode;
+        if (params.operatingHoursName) {
+            const ohResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM OperatingHours WHERE Name = '${params.operatingHoursName.replace(/'/g,"\\'")}' LIMIT 1`)}`);
+            const ohId = ohResp.data.records?.[0]?.Id;
+            if (ohId) payload["OperatingHoursId"] = ohId;
+        }
+        const resp = await client.post("/sobjects/ServiceTerritory", payload);
+        return { success: true, fullName: resp.data.id, created: true, message: `Service Territory '${params.label}' created with ID ${resp.data.id}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createWorkType(auth, params) {
+    try {
+        const client = createClient(auth);
+        const durationInMinutes = params.durationType === "Hours" ? (params.estimatedDuration * 60) : params.estimatedDuration;
+        const payload = {
+            Name: params.label,
+            EstimatedDuration: durationInMinutes,
+            DurationType: "Minutes",
+            BlockTimeBeforeWork: params.blockTimeBeforeWork ?? 0,
+            BlockTimeAfterWork: params.blockTimeAfterWork ?? 0,
+            Description: params.description ?? "",
+        };
+        const resp = await client.post("/sobjects/WorkType", payload);
+        const workTypeId = resp.data.id;
+        // Add skill requirements if provided
+        for (const skillName of (params.skillRequirements ?? [])) {
+            const skillResp = await client.get(`/query?q=${encodeURIComponent(`SELECT Id FROM Skill WHERE DeveloperName = '${skillName.replace(/'/g,"\\'")}' LIMIT 1`)}`);
+            const skillId = skillResp.data.records?.[0]?.Id;
+            if (skillId) await client.post("/sobjects/WorkTypeSkill", { WorkTypeId: workTypeId, SkillId: skillId, SkillType: "Required" }).catch(() => null);
+        }
+        return { success: true, fullName: workTypeId, created: true, message: `Work Type '${params.label}' created with ID ${workTypeId}.` };
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createMessagingChannel(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:MessagingChannel" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.channelName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:channelType>${x(params.channelType)}</met:channelType>
+    <met:isActive>true</met:isActive>
+    ${params.phoneNumber ? `<met:messagingPlatformKey>${x(params.phoneNumber)}</met:messagingPlatformKey>` : ""}
+    ${params.pageId ? `<met:pageId>${x(params.pageId)}</met:pageId>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createChatButton(auth, params) {
+    try {
+        const xml = `<met:metadata xsi:type="met:LiveChatButton" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.buttonName)}</met:fullName>
+    <met:label>${x(params.label)}</met:label>
+    <met:type>Standard</met:type>
+    <met:routingType>${params.routingType === "Bot" ? "Choice" : "Choice"}</met:routingType>
+    <met:optionsHasTimeoutAlert>${params.optionsHasTimeoutAlert ? "true" : "false"}</met:optionsHasTimeoutAlert>
+    <met:windowLanguage>${x(params.windowLanguage ?? "en")}</met:windowLanguage>
+    ${params.queueName ? `<met:overallQueueLength>0</met:overallQueueLength>` : ""}
+    ${params.customAgentName ? `<met:customAgentCrxName>${x(params.customAgentName)}</met:customAgentCrxName>` : ""}
+    ${params.inviteRenderer ? `<met:inviteRenderer>${x(params.inviteRenderer)}</met:inviteRenderer>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createEmbeddedService(auth, params) {
+    try {
+        const isLiveAgent = params.channelType === "LiveAgent";
+        const xml = `<met:metadata xsi:type="met:EmbeddedServiceConfig" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(params.deploymentName)}</met:fullName>
+    <met:masterLabel>${x(params.label)}</met:masterLabel>
+    <met:embeddedServiceType>${isLiveAgent ? "Chat" : "Messaging"}</met:embeddedServiceType>
+    <met:isEnabled>true</met:isEnabled>
+    <met:site>${x(params.site)}</met:site>
+    ${isLiveAgent && params.chatButtonName ? `
+    <met:embeddedServiceLiveAgent>
+        <met:liveChatButton>${x(params.chatButtonName)}</met:liveChatButton>
+        <met:embeddedServiceConfigName>${x(params.deploymentName)}</met:embeddedServiceConfigName>
+        <met:offlineSupportEnabled>false</met:offlineSupportEnabled>
+    </met:embeddedServiceLiveAgent>` : ""}
+    ${!isLiveAgent && params.messagingChannelName ? `<met:embeddedServiceMessaging><met:messagingChannel>${x(params.messagingChannelName)}</met:messagingChannel></met:embeddedServiceMessaging>` : ""}
+    ${params.description ? `<met:description>${x(params.description)}</met:description>` : ""}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
+export async function createBotRouting(auth, params) {
+    try {
+        // Read the existing BotVersion to find the bot's ID
+        const botVersions = await listMetadataType(auth, "BotVersion");
+        if (!botVersions.success) return { success: false, message: "Could not list BotVersions." };
+        const botFullName = botVersions.items.find(i => i.fullName.startsWith(params.botName + "."))?.fullName;
+        if (!botFullName) return { success: false, message: `No BotVersion found for bot '${params.botName}'.` };
+        const escalationsXml = (params.escalationConditions ?? [{ trigger: "agentRequested", action: "TransferToQueue" }]).map((ec, i) => `
+    <met:botDialogs>
+        <met:botSteps>
+            <met:conversationStepType>Transfer</met:conversationStepType>
+            <met:botMessage>${x(params.transferMessage ?? "Connecting you to an agent...")}</met:botMessage>
+            <met:conversationTransfer>
+                <met:transferToType>Queue</met:transferToType>
+                <met:transferToName>${x(params.transferToQueueName)}</met:transferToName>
+            </met:conversationTransfer>
+            <met:stepIdentifier>step_${i + 1}</met:stepIdentifier>
+        </met:botSteps>
+        <met:developerName>Transfer_To_Agent_${i + 1}</met:developerName>
+        <met:isGoalStep>false</met:isGoalStep>
+        <met:label>Transfer To Agent ${i + 1}</met:label>
+        <met:showInFooterMenu>false</met:showInFooterMenu>
+    </met:botDialogs>`).join("");
+        const xml = `<met:metadata xsi:type="met:BotVersion" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <met:fullName>${x(botFullName)}</met:fullName>
+    ${escalationsXml}
+</met:metadata>`;
+        return await upsertMetadata(auth, xml);
+    } catch (err) {
+        return { success: false, message: sanitizeError(err instanceof Error ? err.message : String(err)) };
+    }
+}
 //# sourceMappingURL=salesforce.js.map