@microsoft/app-manifest 1.0.0-alpha.0d2dd4439.0

package/LICENSE

@@ -0,0 +1,23 @@
+Microsoft Teams Toolkit for Visual Studio Code and Teams Toolkit CLI
+
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,115 @@
+## 📦 Package Name
+
+`@microsoft/app-manifest`
+
+---
+
+## 🚀 Summary
+
+A collection of TypeScript definitions and converters for Microsoft 365 App manifests, including:
+
+- **Strongly‑typed interfaces** for three manifest types with all versions:  
+  - Teams Manifest: 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 1.10, 1.11, 1.12, 1.13, 1.14, 1.15, 1.16, 1.17, 1.19, 1.20, devPreview
+  - Declarative Agent Manifest: v1.0, v1.2, v1.3
+  - API Plugin Manifest: v2.1, v2.2
+- **Conversion utilities** between JSON strings and typed manifest objects.  
+- **Utility tools** for:  
+  - Validating manifests against manifest schemas  
+  - Reading/writing manifest files from disk with type checking  
+
+---
+
+## ✨ Features
+
+- **Type‑safe definitions** of all versions generated from Microsoft’s official [JSON schemas](https://developer.microsoft.com/json-schemas/), guaranteeing compile‑time type correctness.
+
+- **Bi‑directional conversion functions** (`jsonToManifest` and `manifestToJson`) for all types and all versions of manifest with runtime type validation.
+
+- **Schema validation utilities** to generate validation errors.
+
+- **File I/O helpers** to conveniently load and dump manifest files in JSON format.
+
+- **Modular versioning**: manifests organized per version file, avoiding type collisions.
+
+## 📥 Installation
+
+```bash
+npm install @microsoft/app-manifest 
+```
+
+## 📖 Usage
+
+### Manipulate manifest
+
+**Automatic version inference**
+
+You can assign a manifest object directly to the discriminated union types (`TeamsManifest`, `DeclarativeAgentManifest` or `APIPluginManifest`) without specifying a concrete version type. TypeScript will infer the specific version based on the `manifestVersion` field:
+
+![not_specify_version](https://github.com/user-attachments/assets/2f10873b-974a-4998-a80c-6bdd6609bdfc)
+
+**Manually specified version**
+
+You can specify a concrete version type:
+
+![specify_version](https://github.com/user-attachments/assets/d6a566af-8b68-41cf-b1a2-a1083e16e6c7)
+
+### Manifest to/from JSON converters
+
+Convert JSON string to manifest type and check the version at run time:
+
+```typescript
+const json = "{ \"manifestVersion\": \"1.20\", \"id\": \"app-id\", ...}";
+const manifest = TeamsManifestConverter.jsonToManifest(json);
+if (manifest.manifestVersion === "1.20") {
+  // TypeScript will infer the type as TeamsManifestV1D20
+  const manifestV1D20 = manifest as TeamsManifestV1D20;
+  // You can now access properties specific to TeamsManifestV1D20
+}
+```
+
+Convert JSON string to manifest type by specifying the version at compile time:
+
+```typescript
+const json = "{ \"manifestVersion\": \"1.20\", \"id\": \"app-id\", ...}";
+const manifest = TeamsManifestConverter.jsonToManifest(json) as TeamsManifestV1D20;
+// You can now access properties specific to TeamsManifestV1D20
+```
+
+Convert manifest object to JSON string:
+
+```typescript
+const jsonString = TeamsManifestConverter.manifestToJson(manifest);
+```
+
+Note that the converts to/from JSON will throw runtime type check failures.
+
+### Manifest utilities
+
+Validate manifest against schema: 
+
+```typescript
+const failures = await AppManifestUtils.validateAgainstSchema(manifest);
+```
+
+Read and write manifest:
+
+```typescript
+const teamsManifestPath = "path/to/your/teams_manifest.json"; 
+// read Teams manifest with type check
+const teamsManifest1 = await AppManifestUtils.readTeamsManifest(teamsManifestPath);
+// read Teams manifest and validate against schema
+const [teamsManifest2, failedValidations1] = await AppManifestUtils.readAndValidateTeamsManifest(teamsManifestPath);
+ 
+const daManifestPath = "path/to/your/da_manifest.json"; 
+// read declarative agent manifest with type check
+const daManifest1 = await AppManifestUtils.readDeclarativeAgentManifest(daManifestPath);
+// read declarative agent manifest and validate against schema
+const [daManifest2, failedValidations2] = await AppManifestUtils.readAndValidateDeclarativeAgentManifest(daManifestPath);
+
+
+const pluginManifestPath = "path/to/your/plugin_manifest.json"; 
+// read API plugin manifest with type check
+const pluginManifest1 = await AppManifestUtils.readApiPluginManifest(pluginManifestPath);
+// read API plugin manifest and validate against schema
+const [pluginManifest2, failedValidations3] = await AppManifestUtils.readAndValidateApiPluginManifest(pluginManifestPath);
+```

package/build/ManifestCommonProperties.d.ts

@@ -0,0 +1,30 @@
+export interface ManifestCommonProperties {
+    /**
+     * Capabilities, e.g. "staticTab" | "configurableTab" | "MessageExtension" | "WebApplicationInfo" | "plugin" | "copilotGpt"
+     */
+    capabilities: string[];
+    /**
+     * Teams app id
+     */
+    id: string;
+    /**
+     * Teams app version, e.g.1.0.0
+     */
+    version: string;
+    /**
+     * manifest version, e.g. 1.16
+     */
+    manifestVersion: string;
+    /**
+     * Whether it's an API ME
+     */
+    isApiME: boolean;
+    /**
+     * Whether it's SPFx Teams app
+     */
+    isSPFx: boolean;
+    /**
+     * Whether it's an API ME with AAD auth
+     */
+    isApiMeAAD: boolean;
+}

package/build/ManifestCommonProperties.js

@@ -0,0 +1,5 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=ManifestCommonProperties.js.map

package/build/ManifestCommonProperties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManifestCommonProperties.js","sourceRoot":"","sources":["../src/ManifestCommonProperties.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC"}

package/build/constants.d.ts

@@ -0,0 +1 @@
+export declare const SharePointAppId = "00000003-0000-0ff1-ce00-000000000000";

package/build/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SharePointAppId = void 0;
+exports.SharePointAppId = "00000003-0000-0ff1-ce00-000000000000";
+//# sourceMappingURL=constants.js.map

package/build/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAErB,QAAA,eAAe,GAAG,sCAAsC,CAAC"}

package/build/declarativeCopilotManifest.d.ts

@@ -0,0 +1,67 @@
+import { ConversationStarter } from "./pluginManifest";
+export declare enum DeclarativeCopilotCapabilityName {
+    WebSearch = "WebSearch",
+    GraphicArt = "GraphicArt",
+    CodeInterpreter = "CodeInterpreter",
+    OneDriveAndSharePoint = "OneDriveAndSharePoint",
+    GraphConnectors = "GraphConnectors",
+    EmbeddedKnowledge = "EmbeddedKnowledge"
+}
+export interface WebSearchCapability {
+    name: DeclarativeCopilotCapabilityName.WebSearch;
+    sites?: Site[];
+}
+export interface GraphicArtCapability {
+    name: DeclarativeCopilotCapabilityName.GraphicArt;
+    [k: string]: unknown;
+}
+export interface CodeInterpreterCapability {
+    name: DeclarativeCopilotCapabilityName.CodeInterpreter;
+    [k: string]: unknown;
+}
+export interface OneDriveAndSharePointCapability {
+    name: DeclarativeCopilotCapabilityName.OneDriveAndSharePoint;
+    items_by_sharepoint_ids?: SharePointIDs[];
+    items_by_url?: Site[];
+}
+export interface GraphConnectorsCapability {
+    name: DeclarativeCopilotCapabilityName.GraphConnectors;
+    connections: Connection[];
+    [k: string]: unknown;
+}
+export interface EmbeddedKnowledgeCapability {
+    name: DeclarativeCopilotCapabilityName.EmbeddedKnowledge;
+    files: File[];
+}
+export interface DeclarativeCopilotManifestSchema {
+    id?: string;
+    name: string;
+    description: string;
+    instructions?: string;
+    capabilities?: (WebSearchCapability | GraphicArtCapability | CodeInterpreterCapability | OneDriveAndSharePointCapability | GraphConnectorsCapability | EmbeddedKnowledgeCapability)[];
+    conversation_starters?: ConversationStarter[];
+    actions?: ActionObject[];
+    [k: string]: unknown;
+}
+export interface SharePointIDs {
+    site_id?: string;
+    web_id?: string;
+    list_id?: string;
+    unique_id?: string;
+}
+export interface File {
+    file_name?: string;
+    file?: string;
+}
+export interface Site {
+    url: string;
+}
+export interface Connection {
+    connection_id: string;
+    [k: string]: unknown;
+}
+export interface ActionObject {
+    id: string;
+    file: string;
+    [k: string]: unknown;
+}

package/build/declarativeCopilotManifest.js

@@ -0,0 +1,15 @@
+"use strict";
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeclarativeCopilotCapabilityName = void 0;
+var DeclarativeCopilotCapabilityName;
+(function (DeclarativeCopilotCapabilityName) {
+    DeclarativeCopilotCapabilityName["WebSearch"] = "WebSearch";
+    DeclarativeCopilotCapabilityName["GraphicArt"] = "GraphicArt";
+    DeclarativeCopilotCapabilityName["CodeInterpreter"] = "CodeInterpreter";
+    DeclarativeCopilotCapabilityName["OneDriveAndSharePoint"] = "OneDriveAndSharePoint";
+    DeclarativeCopilotCapabilityName["GraphConnectors"] = "GraphConnectors";
+    DeclarativeCopilotCapabilityName["EmbeddedKnowledge"] = "EmbeddedKnowledge";
+})(DeclarativeCopilotCapabilityName = exports.DeclarativeCopilotCapabilityName || (exports.DeclarativeCopilotCapabilityName = {}));
+//# sourceMappingURL=declarativeCopilotManifest.js.map

package/build/declarativeCopilotManifest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"declarativeCopilotManifest.js","sourceRoot":"","sources":["../src/declarativeCopilotManifest.ts"],"names":[],"mappings":";AAAA,uCAAuC;AACvC,kCAAkC;;;AAIlC,IAAY,gCAOX;AAPD,WAAY,gCAAgC;IAC1C,2DAAuB,CAAA;IACvB,6DAAyB,CAAA;IACzB,uEAAmC,CAAA;IACnC,mFAA+C,CAAA;IAC/C,uEAAmC,CAAA;IACnC,2EAAuC,CAAA;AACzC,CAAC,EAPW,gCAAgC,GAAhC,wCAAgC,KAAhC,wCAAgC,QAO3C"}

package/build/generated-types/copilot/declarative-agent/DeclarativeAgentManifestV1D0.d.ts

@@ -0,0 +1,163 @@
+/**
+ * The root of the declarative agent manifest document is a JSON object that contains
+ * members that describe the declarative agent.
+ */
+export interface DeclarativeAgentManifestV1D0 {
+    /**
+     * Required. Not localizable. The version of the schema this manifest is using.
+     */
+    version: "v1.0";
+    /**
+     * Optional. Not localizable.
+     */
+    id?: string;
+    /**
+     * Required. Localizable. The name of the declarative agent. It MUST contain at least one
+     * nonwhitespace character and MUST be 100 characters or less.
+     */
+    name: string;
+    /**
+     * Required. Localizable. The description of the declarative agent. It MUST contain at least
+     * one nonwhitespace character and MUST be 1,000 characters or less.
+     */
+    description: string;
+    /**
+     * Optional. Not localizable. The detailed instructions or guidelines on how the declarative
+     * agent should behave, its functions, and any behaviors to avoid. It MUST contain at least
+     * one nonwhitespace character and MUST be 8,000 characters or less.
+     */
+    instructions?: string;
+    /**
+     * Optional. Contains an array of objects that define capabilities of the declarative agent.
+     * There MUST NOT be more than three objects in the array.
+     */
+    capabilities?: CapabilityElement[];
+    /**
+     * Optional. A list of examples of questions that the declarative agent can answer. There
+     * MUST NOT be more than six objects in the array.
+     */
+    conversation_starters?: ConversationStarterElement[];
+    /**
+     * Optional. A list of objects that identify API plugins that provide actions accessible to
+     * the declarative agent.
+     */
+    actions?: ActionElement[];
+    [property: string]: any;
+}
+/**
+ * Identifies an API plugin manifest for a plugin used as an action by the declarative agent.
+ */
+export interface ActionElement {
+    /**
+     * Required. Not localizable. A unique identifier for the action. It MAY be represented by a
+     * GUID.
+     */
+    id: string;
+    /**
+     * Required. Not localizable. A path to the API plugin manifest for this action.
+     */
+    file: string;
+    [property: string]: any;
+}
+/**
+ * Represents a base capability object.
+ *
+ * Indicates that the declarative agent can search the web for grounding information.
+ *
+ * Indicates that the declarative agent can search a user's SharePoint and OneDrive for
+ * grounding information.
+ *
+ * Indicates that the declarative agent can search selected Microsoft Graph connectors for
+ * grounding information.
+ */
+export interface CapabilityElement {
+    /**
+     * Required. Must be WebSearch, OneDriveAndSharePoint or GraphConnectors
+     *
+     * Required. Must be set to WebSearch.
+     *
+     * Required. Must be set to OneDriveAndSharePoint.
+     *
+     * Required. Must be set to GraphConnectors.
+     */
+    name: Name;
+    /**
+     * Optional. An array of objects that identify SharePoint or OneDrive sources using IDs.
+     */
+    items_by_sharepoint_ids?: ItemsBySharepointIDElement[];
+    /**
+     * Optional. An array of objects that identify SharePoint or OneDrive sources by URL.
+     */
+    items_by_url?: ItemsByURLElement[];
+    /**
+     * Optional. An array of objects that identify the Microsoft Graph connectors available to
+     * the declarative agent
+     */
+    connections?: ConnectionElement[];
+    [property: string]: any;
+}
+/**
+ * Identifies a Microsoft Graph connector.
+ */
+export interface ConnectionElement {
+    /**
+     * Required. Not localizable The unique identifier of the Microsoft Graph connector.
+     */
+    connection_id: string;
+    [property: string]: any;
+}
+/**
+ * Contains one or more object identifiers that identify a SharePoint or OneDrive resource.
+ */
+export interface ItemsBySharepointIDElement {
+    /**
+     * Optional. Not localizable. The GUID identifier of a SharePoint or OneDrive site.
+     */
+    site_id?: string;
+    /**
+     * Optional. Not localizable. The GUID identifier of a SharePoint or OneDrive web.
+     */
+    web_id?: string;
+    /**
+     * Optional. Not localizable. The GUID identifier of a SharePoint or OneDrive list.
+     */
+    list_id?: string;
+    /**
+     * Optional. Not localizable. The GUID identifier of a SharePoint or OneDrive item.
+     */
+    unique_id?: string;
+}
+/**
+ * Represents the URL of a SharePoint or OneDrive resource.
+ */
+export interface ItemsByURLElement {
+    /**
+     * Optional. Not localizable. An absolute URL to a SharePoint or OneDrive resource.
+     */
+    url?: string;
+}
+/**
+ * Required. Must be WebSearch, OneDriveAndSharePoint or GraphConnectors
+ */
+export type Name = "WebSearch" | "OneDriveAndSharePoint" | "GraphConnectors";
+/**
+ * Contains hints that are displayed to the user to demonstrate how they can get started
+ * using the declarative agent.
+ */
+export interface ConversationStarterElement {
+    /**
+     * Required. Localizable. A suggestion that the user can use to obtain the desired result
+     * from the DC. It MUST contain at least one nonwhitespace character.
+     */
+    text: string;
+    /**
+     * Optional. Localizable. A unique title for the conversation starter. It MUST contain at
+     * least one nonwhitespace character.
+     */
+    title?: string;
+    [property: string]: any;
+}
+export declare class Convert {
+    static toDeclarativeAgentManifestV1D0(json: string): DeclarativeAgentManifestV1D0;
+    static declarativeAgentManifestV1D0ToJson(value: DeclarativeAgentManifestV1D0): string;
+}

package/build/generated-types/copilot/declarative-agent/DeclarativeAgentManifestV1D0.js

@@ -0,0 +1,214 @@
+"use strict";
+// To parse this data:
+//
+//   import { Convert, DeclarativeAgentManifestV1D0 } from "./file";
+//
+//   const declarativeAgentManifestV1D0 = Convert.toDeclarativeAgentManifestV1D0(json);
+//
+// These functions will throw an error if the JSON doesn't
+// match the expected interface, even if the JSON is valid.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Convert = void 0;
+// Converts JSON strings to/from your types
+// and asserts the results of JSON.parse at runtime
+class Convert {
+    static toDeclarativeAgentManifestV1D0(json) {
+        return cast(JSON.parse(json), r("DeclarativeAgentManifestV1D0"));
+    }
+    static declarativeAgentManifestV1D0ToJson(value) {
+        return JSON.stringify(uncast(value, r("DeclarativeAgentManifestV1D0")), null, 4);
+    }
+}
+exports.Convert = Convert;
+function invalidValue(typ, val, key, parent = '') {
+    const prettyTyp = prettyTypeName(typ);
+    const parentText = parent ? ` on ${parent}` : '';
+    const keyText = key ? ` for key "${key}"` : '';
+    throw Error(`Invalid value${keyText}${parentText}. Expected ${prettyTyp} but got ${JSON.stringify(val)}`);
+}
+function prettyTypeName(typ) {
+    if (Array.isArray(typ)) {
+        if (typ.length === 2 && typ[0] === undefined) {
+            return `an optional ${prettyTypeName(typ[1])}`;
+        }
+        else {
+            return `one of [${typ.map(a => { return prettyTypeName(a); }).join(", ")}]`;
+        }
+    }
+    else if (typeof typ === "object" && typ.literal !== undefined) {
+        return typ.literal;
+    }
+    else {
+        return typeof typ;
+    }
+}
+function jsonToJSProps(typ) {
+    if (typ.jsonToJS === undefined) {
+        const map = {};
+        typ.props.forEach((p) => map[p.json] = { key: p.js, typ: p.typ });
+        typ.jsonToJS = map;
+    }
+    return typ.jsonToJS;
+}
+function jsToJSONProps(typ) {
+    if (typ.jsToJSON === undefined) {
+        const map = {};
+        typ.props.forEach((p) => map[p.js] = { key: p.json, typ: p.typ });
+        typ.jsToJSON = map;
+    }
+    return typ.jsToJSON;
+}
+function transform(val, typ, getProps, key = '', parent = '') {
+    function transformPrimitive(typ, val) {
+        if (typeof typ === typeof val)
+            return val;
+        return invalidValue(typ, val, key, parent);
+    }
+    function transformUnion(typs, val) {
+        // val must validate against one typ in typs
+        const l = typs.length;
+        for (let i = 0; i < l; i++) {
+            const typ = typs[i];
+            try {
+                return transform(val, typ, getProps);
+            }
+            catch (_) { }
+        }
+        return invalidValue(typs, val, key, parent);
+    }
+    function transformEnum(cases, val) {
+        if (cases.indexOf(val) !== -1)
+            return val;
+        return invalidValue(cases.map(a => { return l(a); }), val, key, parent);
+    }
+    function transformArray(typ, val) {
+        // val must be an array with no invalid elements
+        if (!Array.isArray(val))
+            return invalidValue(l("array"), val, key, parent);
+        return val.map(el => transform(el, typ, getProps));
+    }
+    function transformDate(val) {
+        if (val === null) {
+            return null;
+        }
+        const d = new Date(val);
+        if (isNaN(d.valueOf())) {
+            return invalidValue(l("Date"), val, key, parent);
+        }
+        return d;
+    }
+    function transformObject(props, additional, val) {
+        if (val === null || typeof val !== "object" || Array.isArray(val)) {
+            return invalidValue(l(ref || "object"), val, key, parent);
+        }
+        const result = {};
+        Object.getOwnPropertyNames(props).forEach(key => {
+            const prop = props[key];
+            const v = Object.prototype.hasOwnProperty.call(val, key) ? val[key] : undefined;
+            result[prop.key] = transform(v, prop.typ, getProps, key, ref);
+        });
+        Object.getOwnPropertyNames(val).forEach(key => {
+            if (!Object.prototype.hasOwnProperty.call(props, key)) {
+                result[key] = transform(val[key], additional, getProps, key, ref);
+            }
+        });
+        return result;
+    }
+    if (typ === "any")
+        return val;
+    if (typ === null) {
+        if (val === null)
+            return val;
+        return invalidValue(typ, val, key, parent);
+    }
+    if (typ === false)
+        return invalidValue(typ, val, key, parent);
+    let ref = undefined;
+    while (typeof typ === "object" && typ.ref !== undefined) {
+        ref = typ.ref;
+        typ = typeMap[typ.ref];
+    }
+    if (Array.isArray(typ))
+        return transformEnum(typ, val);
+    if (typeof typ === "object") {
+        return typ.hasOwnProperty("unionMembers") ? transformUnion(typ.unionMembers, val)
+            : typ.hasOwnProperty("arrayItems") ? transformArray(typ.arrayItems, val)
+                : typ.hasOwnProperty("props") ? transformObject(getProps(typ), typ.additional, val)
+                    : invalidValue(typ, val, key, parent);
+    }
+    // Numbers can be parsed by Date but shouldn't be.
+    if (typ === Date && typeof val !== "number")
+        return transformDate(val);
+    return transformPrimitive(typ, val);
+}
+function cast(val, typ) {
+    return transform(val, typ, jsonToJSProps);
+}
+function uncast(val, typ) {
+    return transform(val, typ, jsToJSONProps);
+}
+function l(typ) {
+    return { literal: typ };
+}
+function a(typ) {
+    return { arrayItems: typ };
+}
+function u(...typs) {
+    return { unionMembers: typs };
+}
+function o(props, additional) {
+    return { props, additional };
+}
+function m(additional) {
+    return { props: [], additional };
+}
+function r(name) {
+    return { ref: name };
+}
+const typeMap = {
+    "DeclarativeAgentManifestV1D0": o([
+        { json: "version", js: "version", typ: r("Version") },
+        { json: "id", js: "id", typ: u(undefined, "") },
+        { json: "name", js: "name", typ: "" },
+        { json: "description", js: "description", typ: "" },
+        { json: "instructions", js: "instructions", typ: u(undefined, "") },
+        { json: "capabilities", js: "capabilities", typ: u(undefined, a(r("CapabilityElement"))) },
+        { json: "conversation_starters", js: "conversation_starters", typ: u(undefined, a(r("ConversationStarterElement"))) },
+        { json: "actions", js: "actions", typ: u(undefined, a(r("ActionElement"))) },
+    ], "any"),
+    "ActionElement": o([
+        { json: "id", js: "id", typ: "" },
+        { json: "file", js: "file", typ: "" },
+    ], "any"),
+    "CapabilityElement": o([
+        { json: "name", js: "name", typ: r("Name") },
+        { json: "items_by_sharepoint_ids", js: "items_by_sharepoint_ids", typ: u(undefined, a(r("ItemsBySharepointIDElement"))) },
+        { json: "items_by_url", js: "items_by_url", typ: u(undefined, a(r("ItemsByURLElement"))) },
+        { json: "connections", js: "connections", typ: u(undefined, a(r("ConnectionElement"))) },
+    ], "any"),
+    "ConnectionElement": o([
+        { json: "connection_id", js: "connection_id", typ: "" },
+    ], "any"),
+    "ItemsBySharepointIDElement": o([
+        { json: "site_id", js: "site_id", typ: u(undefined, "") },
+        { json: "web_id", js: "web_id", typ: u(undefined, "") },
+        { json: "list_id", js: "list_id", typ: u(undefined, "") },
+        { json: "unique_id", js: "unique_id", typ: u(undefined, "") },
+    ], false),
+    "ItemsByURLElement": o([
+        { json: "url", js: "url", typ: u(undefined, "") },
+    ], false),
+    "ConversationStarterElement": o([
+        { json: "text", js: "text", typ: "" },
+        { json: "title", js: "title", typ: u(undefined, "") },
+    ], "any"),
+    "Name": [
+        "GraphConnectors",
+        "OneDriveAndSharePoint",
+        "WebSearch",
+    ],
+    "Version": [
+        "v1.0",
+    ],
+};
+//# sourceMappingURL=DeclarativeAgentManifestV1D0.js.map