export interface TeamsManifestVDevPreview {
    $schema?: string;
    /**
     * The version of the schema this manifest is using.
     */
    manifestVersion: ManifestVersion;
    /**
     * The version of the app. Changes to your manifest should cause a version change. This
     * version string must follow the semver standard (http://semver.org).
     */
    version: string;
    /**
     * A unique identifier for this app. This id must be a GUID.
     */
    id: string;
    /**
     * A unique identifier for this app in reverse domain notation. E.g: com.example.myapp
     */
    packageName?: string;
    localizationInfo?: LocalizationInfo;
    developer: Developer;
    name: NameClass;
    description: Description;
    icons: Icons;
    /**
     * A color to use in conjunction with the icon. The value must be a valid HTML color code
     * starting with '#', for example `#4464ee`.
     */
    accentColor: string;
    /**
     * These are tabs users can optionally add to their channels and 1:1 or group chats and
     * require extra configuration before they are added. Configurable tabs are not supported in
     * the personal scope. Currently only one configurable tab per app is supported.
     */
    configurableTabs?: ConfigurableTab[];
    /**
     * A set of tabs that may be 'pinned' by default, without the user adding them manually.
     * Static tabs declared in personal scope are always pinned to the app's personal
     * experience. Static tabs do not currently support the 'teams' scope.
     */
    staticTabs?: StaticTab[];
    /**
     * The set of bots for this app. Currently only one bot per app is supported.
     */
    bots?: Bot[];
    /**
     * The set of Office365 connectors for this app. Currently only one connector per app is
     * supported.
     */
    connectors?: Connector[];
    /**
     * Subscription offer associated with this app.
     */
    subscriptionOffer?: SubscriptionOffer;
    /**
     * The set of compose extensions for this app. Currently only one compose extension per app
     * is supported.
     */
    composeExtensions?: ComposeExtension[];
    scopeConstraints?: ScopeConstraints;
    /**
     * Specifies the permissions the app requests from users.
     */
    permissions?: Permission[];
    /**
     * Specify the native features on a user's device that your app may request access to.
     */
    devicePermissions?: DevicePermission[];
    /**
     * A list of valid domains from which the tabs expect to load any content. Domain listings
     * can include wildcards, for example `*.example.com`. If your tab configuration or content
     * UI needs to navigate to any other domain besides the one use for tab configuration, that
     * domain must be specified here.
     */
    validDomains?: string[];
    /**
     * Specify your AAD App ID and Graph information to help users seamlessly sign into your AAD
     * app.
     */
    webApplicationInfo?: WebApplicationInfo;
    /**
     * Specify the app's Graph connector configuration. If this is present then
     * webApplicationInfo.id must also be specified.
     */
    graphConnector?: GraphConnector;
    /**
     * A value indicating whether or not show loading indicator when app/tab is loading
     */
    showLoadingIndicator?: boolean;
    /**
     * A value indicating whether a personal app is rendered without a tab header-bar
     */
    isFullScreen?: boolean;
    activities?: Activities;
    /**
     * The set of supported channel type that an app belongs to
     */
    supportedChannelTypes?: SupportedChannelType[];
    /**
     * A property in the app manifest that declares support for all channel features,
     * categorized by tiers.
     */
    supportsChannelFeatures?: SupportsChannelFeatures;
    /**
     * A list of tenant configured properties for an app
     */
    configurableProperties?: ConfigurableProperty[];
    /**
     * A value indicating whether an app is blocked by default until admin allows it
     */
    defaultBlockUntilAdminAction?: boolean;
    /**
     * The url to the page that provides additional app information for the admins
     */
    publisherDocsUrl?: string;
    /**
     * The install scope defined for this app by default. This will be the option displayed on
     * the button when a user tries to add the app
     */
    defaultInstallScope?: DefaultInstallScope;
    /**
     * When a group install scope is selected, this will define the default capability when the
     * user installs the app
     */
    defaultGroupCapability?: DefaultGroupCapability;
    /**
     * Specify meeting extension definition.
     */
    meetingExtensionDefinition?: MeetingExtensionDefinition;
    /**
     * Specify and consolidates authorization related information for the App.
     */
    authorization?: TeamsManifestVDevPreviewAuthorization;
    extensions?: ElementExtension[];
    actions?: ElementAction[];
    /**
     * Defines the list of cards which could be pinned to dashboards that can provide summarized
     * view of information relevant to user.
     */
    dashboardCards?: DashboardCard[];
    /**
     * The Intune-related properties for the app.
     */
    intuneInfo?: IntuneInfo;
    copilotAgents?: CopilotAgents;
    /**
     * An array of agentic user templates references.
     */
    agenticUserTemplates?: AgenticUserTemplateRef[];
    elementRelationshipSet?: ElementRelationshipSet;
    /**
     * Optional property containing background loading configuration. By opting into this
     * performance enhancement, your app is eligible to be loaded in the background in any
     * Microsoft 365 application host that supports this feature. Note that setting this
     * property gives the host client permission to load the app in the background but does not
     * guarantee the app will be preloaded at runtime. Whether an app is preloaded in the
     * background will be dynamically determined based on usage and other criteria.
     */
    backgroundLoadConfiguration?: BackgroundLoadConfiguration;
    /**
     * A list of agent connector objects to included in the Unified App Manifest.
     */
    agentConnectors?: AgentConnector[];
}
/**
 * Actions node contains an array of actions object.
 */
export interface ElementAction {
    /**
     * A unique identifier string in the default locale that is used to catalog actions.
     */
    id: string;
    /**
     * An enum string that describes the intent of the action.
     */
    intent: Intent;
    /**
     * A display name for the action.
     */
    displayName: string;
    /**
     * A display string in the default locale to represent the action.
     */
    description: string;
    /**
     * Object containing URLs to icon images for this action intent.
     */
    icons?: Icon[];
    /**
     * Defining how actions can be handled. If an app has more than 1 handler, only one
     * experience will show up at one entry point. The hub will decide which action to show up
     * based on which experience is supported.
     */
    handlers: Handler[];
}
export interface Handler {
    /**
     * Required both for File Handlers and Content Actions.
     */
    type: HandlerType;
    supportedObjects?: SupportedObjects;
    /**
     * If true, multiple files can be selected and the action will still be displayed. If false
     * or missing, the action is only displayed when a single item is selected.
     */
    supportsMultiSelect?: boolean;
    pageInfo?: PageInfo;
    dialogInfo?: DialogInfo;
    /**
     * Url for handler type openURL, invokeAPI, openTaskpane, and others.
     */
    url?: string;
    botInfo?: BotInfo;
    [property: string]: any;
}
export interface BotInfo {
    /**
     * Bot ID.
     */
    botId: string;
    /**
     * Fetch task from bot.
     */
    fetchTask?: boolean;
    [property: string]: any;
}
export interface DialogInfo {
    /**
     * Dialog type, defines how the developer build the dialog.
     */
    dialogType: DialogType;
    /**
     * Required for html based dialog.
     */
    url?: string;
    /**
     * Dialog width - either a number in pixels or default layout such as 'large', 'medium', or
     * 'small'.
     */
    width: string;
    /**
     * Dialog height - either a number in pixels or default layout such as 'large', 'medium', or
     * 'small'.
     */
    height: string;
    /**
     * Array of parameter object, each contains: name, title, description, inputType.
     */
    parameters?: ParameterObject[];
    /**
     * Dialog title.
     */
    title?: string;
    [property: string]: any;
}
/**
 * Dialog type, defines how the developer build the dialog.
 */
export type DialogType = "url" | "adaptiveCard";
export interface ParameterObject {
    /**
     * Parameter name.
     */
    name: string;
    /**
     * Parameter title.
     */
    title: string;
    /**
     * Parameter description.
     */
    description: string;
    /**
     * Parameter input type.
     */
    inputType: string;
    [property: string]: any;
}
export interface PageInfo {
    /**
     * Used to navigate to the page in MetaOS app.
     */
    pageId: string;
    /**
     * Used to navigate to the subpage in MetaOS app.
     */
    subpageId?: string;
    [property: string]: any;
}
export interface SupportedObjects {
    file?: File;
    /**
     * A null value indicates that the file handler is not available when a folder is selected.
     * An object with no parameters indicates that the file handler is available when a folder
     * is selected or when no files are selected.
     */
    folder?: {
        [key: string]: any;
    } | null;
    [property: string]: any;
}
export interface File {
    extensions?: string[];
}
/**
 * Required both for File Handlers and Content Actions.
 */
export type HandlerType = "openURL" | "openPage" | "openDialog" | "openTaskpane" | "invokeAPI" | "invokeBot";
export interface Icon {
    /**
     * Icon size in pixels.
     */
    size: number;
    /**
     * URL for the icon.
     */
    url: string;
}
/**
 * An enum string that describes the intent of the action.
 */
export type Intent = "create" | "addTo" | "open" | "preview" | "share" | "sign" | "custom";
export interface Activities {
    /**
     * Specify the types of activites that your app can post to a users activity feed
     */
    activityTypes?: ActivityType[];
    /**
     * Specify the customized icons that your app can post to a users activity feed
     */
    activityIcons?: ActivityIcon[];
}
export interface ActivityIcon {
    /**
     * Represents the unique icon ID.
     */
    id: string;
    /**
     * Represents the relative path to the icon image. Image should be size 32x32.
     */
    iconFile: string;
}
export interface ActivityType {
    type: string;
    description: string;
    templateText: string;
    /**
     * An array containing valid icon IDs per activity type.
     */
    allowedIconIds?: string[];
}
/**
 * An agent connector represents a mechanism to enable agents to access information from
 * systems outside of Microsoft 365, often via an MCP Server. Other mechanisms include using
 * OpenAPI descriptions for calling external HTTP APIs. The role of the agent connector is
 * to provide the necessary configuration information to agents or other M365 applications
 * to connect to these external systems. An agent connector can be provided for use by other
 * elements described within the same Unified App Manifest, or as a standalone resource that
 * can be referenced in the Unified App Manifest of other M365 applications.
 */
export interface AgentConnector {
    /**
     * Unique identifier for the agent connector
     */
    id: string;
    /**
     * Indicates whether this connector can be reused by other applications.
     */
    reusable?: boolean;
    /**
     * A user-friendly name for the connector, which can be displayed in UIs.
     */
    displayName: string;
    /**
     * A brief description of the connector's purpose and functionality.
     */
    description?: string;
    /**
     * Configuration details for connectors that provide tools for agents, either via a plugin,
     * a remote MCP server or a local MCP server. One and only one of the above properties MUST
     * be defined within a tool source object.
     */
    toolSource?: ToolSource;
}
/**
 * Configuration details for connectors that provide tools for agents, either via a plugin,
 * a remote MCP server or a local MCP server. One and only one of the above properties MUST
 * be defined within a tool source object.
 */
export interface ToolSource {
    /**
     * Configuration details for connectors that leverage a Plugin Manifest. Either both id and
     * file properties must be provided (for external plugin reference), or only the description
     * property must be provided (for inline plugin manifest).
     */
    plugin?: Plugin;
    remoteMcpServer?: RemoteMCPServer;
    localMcpServer?: LocalMCPServer;
}
export interface LocalMCPServer {
    /**
     * The unique identifier of the local MCP Server deployed via some secure mechanism to the
     * user's desktop.
     */
    mcpServerIdentifier: string;
    /**
     * Configuration for MCP tool descriptions, either by file reference or inline content (but
     * not both). When this property is present it indicates that dynamic discovery will not be
     * used.
     */
    mcpToolDescription?: LocalMCPServerMCPToolDescription;
    /**
     * Authorization configuration for connecting to the local MCP server. The design mirrors
     * that of Plugin Manifests
     * https://learn.microsoft.com/microsoft-365-copilot/extensibility/api-plugin-manifest-2.3
     */
    authorization?: LocalMCPServerAuthorization;
}
/**
 * Authorization configuration for connecting to the local MCP server. The design mirrors
 * that of Plugin Manifests
 * https://learn.microsoft.com/microsoft-365-copilot/extensibility/api-plugin-manifest-2.3
 */
export interface LocalMCPServerAuthorization {
    /**
     * The type of authorization required to invoke the MCP server. Supported values are: 'None'
     * (anonymous access), 'OAuthPluginVault' (OAuth flow with referenceId), 'ApiKeyPluginVault'
     * (API Key with referenceId), 'DynamicClientRegistration' (dynamic client registration with
     * referenceId).
     */
    type: AuthorizationType;
    /**
     * (maxLength: 128)    A reference identifier used when type is OAuthPluginVault,
     * ApiKeyPluginVault, or DynamicClientRegistration. The referenceId value is acquired
     * independently when providing the necessary authorization configuration values. This
     * mechanism exists to prevent the need for storing secret values in the plugin manifest.
     */
    referenceId?: string;
}
/**
 * The type of authorization required to invoke the MCP server. Supported values are: 'None'
 * (anonymous access), 'OAuthPluginVault' (OAuth flow with referenceId), 'ApiKeyPluginVault'
 * (API Key with referenceId), 'DynamicClientRegistration' (dynamic client registration with
 * referenceId).
 */
export type AuthorizationType = "None" | "OAuthPluginVault" | "ApiKeyPluginVault" | "DynamicClientRegistration";
/**
 * Configuration for MCP tool descriptions, either by file reference or inline content (but
 * not both). When this property is present it indicates that dynamic discovery will not be
 * used.
 */
export interface LocalMCPServerMCPToolDescription {
    /**
     * The relative path to the MCP tool description file within the app package.
     */
    file?: string;
    /**
     * An inline JSON object containing the tool descriptions directly. The contents match the
     * results of calling the 'tools/list' method on the MCP Server.
     */
    description?: {
        [key: string]: any;
    };
}
/**
 * Configuration details for connectors that leverage a Plugin Manifest. Either both id and
 * file properties must be provided (for external plugin reference), or only the description
 * property must be provided (for inline plugin manifest).
 */
export interface Plugin {
    /**
     * The unique identifier of the plugin that provides the tools.
     */
    id?: string;
    /**
     * The relative path to the plugin manifest file within the app package.
     */
    file?: string;
    /**
     * An inlined Plugin Manifest object for simple plugins that do not require a separate file.
     * It should conform to the Plugin Manifest schema
     * https://learn.microsoft.com/microsoft-365-copilot/extensibility/api-plugin-manifest-2.3.
     */
    description?: {
        [key: string]: any;
    };
}
export interface RemoteMCPServer {
    /**
     * The URL of the remote MCP Server.
     */
    mcpServerUrl: string;
    /**
     * Configuration for MCP tool descriptions, either by file reference or inline content (but
     * not both). When this property is present it indicates that dynamic discovery will not be
     * used.
     */
    mcpToolDescription?: RemoteMCPServerMCPToolDescription;
    /**
     * Authorization configuration for connecting to the local MCP server. The design mirrors
     * that of Plugin Manifests
     * https://learn.microsoft.com/microsoft-365-copilot/extensibility/api-plugin-manifest-2.3
     */
    authorization?: RemoteMCPServerAuthorization;
}
/**
 * Authorization configuration for connecting to the local MCP server. The design mirrors
 * that of Plugin Manifests
 * https://learn.microsoft.com/microsoft-365-copilot/extensibility/api-plugin-manifest-2.3
 */
export interface RemoteMCPServerAuthorization {
    /**
     * The type of authorization required to invoke the MCP server. Supported values are: 'None'
     * (anonymous access), 'OAuthPluginVault' (OAuth flow with referenceId), 'ApiKeyPluginVault'
     * (API Key with referenceId), 'DynamicClientRegistration' (dynamic client registration with
     * referenceId).
     */
    type: AuthorizationType;
    /**
     * A reference identifier used when type is OAuthPluginVault, ApiKeyPluginVault, or
     * DynamicClientRegistration. The referenceId value is acquired independently when providing
     * the necessary authorization configuration values. This mechanism exists to prevent the
     * need for storing secret values in the plugin manifest.
     */
    referenceId?: string;
}
/**
 * Configuration for MCP tool descriptions, either by file reference or inline content (but
 * not both). When this property is present it indicates that dynamic discovery will not be
 * used.
 */
export interface RemoteMCPServerMCPToolDescription {
    /**
     * The relative path to the MCP tool description file within the app package.
     */
    file?: string;
    /**
     * An inline JSON object containing the tool descriptions directly. The contents match the
     * results of calling the 'tools/list' method on the MCP Server.
     */
    description?: {
        [key: string]: any;
    };
}
export interface AgenticUserTemplateRef {
    /**
     * Unique identifier for the agentic user template. Must contain only alphanumeric
     * characters, dots, underscores, and hyphens.
     */
    id: string;
    /**
     * Relative file path to this agentic user template element file in the application package.
     */
    file: string;
}
/**
 * Specify and consolidates authorization related information for the App.
 */
export interface TeamsManifestVDevPreviewAuthorization {
    /**
     * List of permissions that the app needs to function.
     */
    permissions?: Permissions;
}
/**
 * List of permissions that the app needs to function.
 */
export interface Permissions {
    /**
     * Permissions that guard data access on a resource instance level.
     */
    resourceSpecific?: ResourceSpecific[];
}
export interface ResourceSpecific {
    /**
     * The name of the resource-specific permission.
     */
    name: string;
    /**
     * The type of the resource-specific permission.
     */
    type: ResourceSpecificType;
}
/**
 * The type of the resource-specific permission.
 */
export type ResourceSpecificType = "Application" | "Delegated";
/**
 * Optional property containing background loading configuration. By opting into this
 * performance enhancement, your app is eligible to be loaded in the background in any
 * Microsoft 365 application host that supports this feature. Note that setting this
 * property gives the host client permission to load the app in the background but does not
 * guarantee the app will be preloaded at runtime. Whether an app is preloaded in the
 * background will be dynamically determined based on usage and other criteria.
 */
export interface BackgroundLoadConfiguration {
    /**
     * Optional property within backgroundLoadConfiguration containing tab settings for
     * background loading. Setting tabConfiguration indicates that the app supports background
     * loading of tabs.
     */
    tabConfiguration?: TabConfiguration;
}
/**
 * Optional property within backgroundLoadConfiguration containing tab settings for
 * background loading. Setting tabConfiguration indicates that the app supports background
 * loading of tabs.
 */
export interface TabConfiguration {
    /**
     * Required URL for background loading. This can be the same contentUrl from the staticTabs
     * section or an alternative endpoint used for background loading.
     */
    contentUrl: string;
}
export interface Bot {
    /**
     * The Microsoft App ID specified for the bot in the Bot Framework portal
     * (https://dev.botframework.com/bots)
     */
    botId: string;
    configuration?: Configuration;
    /**
     * This value describes whether or not the bot utilizes a user hint to add the bot to a
     * specific channel.
     */
    needsChannelSelector?: boolean;
    /**
     * A value indicating whether or not the bot is a one-way notification only bot, as opposed
     * to a conversational bot.
     */
    isNotificationOnly?: boolean;
    /**
     * A value indicating whether the team's Office group needs to be security enabled.
     */
    requiresSecurityEnabledGroup?: boolean;
    /**
     * A value indicating whether the bot supports uploading/downloading of files.
     */
    supportsFiles?: boolean;
    /**
     * A value indicating whether the bot supports audio calling.
     */
    supportsCalling?: boolean;
    /**
     * A value indicating whether the bot supports video calling.
     */
    supportsVideo?: boolean;
    /**
     * A property set by developers to opt-in to sessions.
     */
    supportsSessions?: boolean;
    /**
     * Specifies whether the bot offers an experience in the context of a channel in a team, in
     * a group chat (groupChat), an experience scoped to an individual user alone (personal) OR
     * within Copilot surfaces. These options are non-exclusive.
     */
    scopes: CommandListScope[];
    /**
     * The list of commands that the bot supplies, including their usage, description, and the
     * scope for which the commands are valid. A separate command list should be used for each
     * scope.
     */
    commandLists?: CommandList[];
    /**
     * The set of requirements for the bot.
     */
    requirementSet?: ElementRequirementSet;
    /**
     * System‑generated metadata. This information is maintained by Microsoft services and must
     * not be modified manually.
     */
    registrationInfo?: RegistrationInfo;
}
export interface CommandList {
    /**
     * Specifies the scopes for which the command list is valid
     */
    scopes: CommandListScope[];
    commands: CommandListCommand[];
}
export interface CommandListCommand {
    /**
     * The bot command name
     */
    title: string;
    /**
     * A simple text description or an example of the command syntax and its arguments.
     */
    description: string;
}
export type CommandListScope = "team" | "personal" | "groupChat" | "copilot";
export interface Configuration {
    team?: ConfigurationTeam;
    groupChat?: ConfigurationGroupChat;
}
export interface ConfigurationGroupChat {
    /**
     * A boolean value that indicates if it should fetch bot config task module dynamically.
     */
    fetchTask?: boolean;
    /**
     * Task module to be launched when fetch task set to false.
     */
    taskInfo?: TaskInfo;
}
/**
 * Task module to be launched when fetch task set to false.
 */
export interface TaskInfo {
    /**
     * Initial dialog title.
     */
    title?: string;
    /**
     * Dialog width - either a number in pixels or default layout such as 'large', 'medium', or
     * 'small'.
     */
    width?: string;
    /**
     * Dialog height - either a number in pixels or default layout such as 'large', 'medium', or
     * 'small'.
     */
    height?: string;
    /**
     * Initial webview URL.
     */
    url?: string;
}
export interface ConfigurationTeam {
    /**
     * A boolean value that indicates if it should fetch bot config task module dynamically.
     */
    fetchTask?: boolean;
    /**
     * Task module to be launched when fetch task set to false.
     */
    taskInfo?: TaskInfo;
}
/**
 * System‑generated metadata. This information is maintained by Microsoft services and must
 * not be modified manually.
 */
export interface RegistrationInfo {
    /**
     * The partner source through which the bot is registered. System‑generated metadata. This
     * information is maintained by Microsoft services and must not be modified manually.
     */
    source: Source;
    /**
     * A Power Platform environment that serves as a container for building apps under a
     * Microsoft 365 tenant and can only be accessed by users within that tenant.
     * System‑generated metadata. This information is maintained by Microsoft services and must
     * not be modified manually.
     */
    environment?: string;
    /**
     * The Copilot Studio copilot schema name. System‑generated metadata. This information is
     * maintained by Microsoft services and must not be modified manually.
     */
    schemaName?: string;
    /**
     * The core services cluster category for Copilot Studio copilots. System‑generated
     * metadata. This information is maintained by Microsoft services and must not be modified
     * manually.
     */
    clusterCategory?: string;
}
/**
 * The partner source through which the bot is registered. System‑generated metadata. This
 * information is maintained by Microsoft services and must not be modified manually.
 */
export type Source = "standard" | "microsoftCopilotStudio" | "onedriveSharepoint";
/**
 * The set of requirements for the tab.
 *
 * An object representing a set of requirements that the host must support for the element.
 *
 * The set of requirements for the bot.
 *
 * The set of requirements for the compose extension.
 */
export interface ElementRequirementSet {
    hostMustSupportFunctionalities: HostFunctionality[];
}
/**
 * An object representing a specific functionality that a host must support.
 */
export interface HostFunctionality {
    /**
     * The name of the functionality.
     */
    name: HostMustSupportFunctionalityName;
}
/**
 * The name of the functionality.
 */
export type HostMustSupportFunctionalityName = "dialogUrl" | "dialogUrlBot" | "dialogAdaptiveCard" | "dialogAdaptiveCardBot";
export interface ComposeExtension {
    /**
     * A unique identifier for the compose extension.
     */
    id?: string;
    /**
     * The Microsoft App ID specified for the bot powering the compose extension in the Bot
     * Framework portal (https://dev.botframework.com/bots)
     */
    botId?: string;
    /**
     * Type of the compose extension.
     */
    composeExtensionType?: ComposeExtensionType;
    /**
     * Object capturing authorization information.
     */
    authorization?: ComposeExtensionAuthorization;
    /**
     * A relative file path to the api specification file in the manifest package.
     */
    apiSpecificationFile?: string;
    /**
     * A value indicating whether the configuration of a compose extension can be updated by the
     * user.
     */
    canUpdateConfiguration?: boolean | null;
    commands?: ComposeExtensionCommand[];
    /**
     * A list of handlers that allow apps to be invoked when certain conditions are met
     */
    messageHandlers?: MessageHandler[];
    /**
     * The set of requirements for the compose extension.
     */
    requirementSet?: ElementRequirementSet;
}
/**
 * Object capturing authorization information.
 */
export interface ComposeExtensionAuthorization {
    /**
     * Enum of possible authorization types.
     */
    authType?: AuthType;
    /**
     * Object capturing details needed to do microsoftEntra auth flow. It will be only present
     * when auth type is microsoftEntra.
     */
    microsoftEntraConfiguration?: MicrosoftEntraConfiguration;
    /**
     * Object capturing details needed to do service auth. It will be only present when auth
     * type is apiSecretServiceAuth.
     */
    apiSecretServiceAuthConfiguration?: APISecretServiceAuthConfiguration;
    /**
     * Object capturing details needed to match the application's OAuth configuration for the
     * app. This should be and must be populated only when authType is set to oAuth2.0r
     */
    oAuthConfiguration?: OAuthConfiguration;
}
/**
 * Object capturing details needed to do service auth. It will be only present when auth
 * type is apiSecretServiceAuth.
 */
export interface APISecretServiceAuthConfiguration {
    /**
     * Registration id returned when developer submits the api key through Developer Portal.
     */
    apiSecretRegistrationId?: string;
}
/**
 * Enum of possible authorization types.
 */
export type AuthType = "none" | "apiSecretServiceAuth" | "microsoftEntra" | "oAuth2.0";
/**
 * Object capturing details needed to do microsoftEntra auth flow. It will be only present
 * when auth type is microsoftEntra.
 */
export interface MicrosoftEntraConfiguration {
    /**
     * Boolean indicating whether single sign on is configured for the app.
     */
    supportsSingleSignOn?: boolean;
}
/**
 * Object capturing details needed to match the application's OAuth configuration for the
 * app. This should be and must be populated only when authType is set to oAuth2.0r
 */
export interface OAuthConfiguration {
    /**
     * The oAuth configuration id obtained by the Developer when registering their configuration
     * in Developer Portal.
     */
    oAuthConfigurationId?: string;
}
export interface ComposeExtensionCommand {
    /**
     * Id of the command.
     */
    id: string;
    /**
     * Type of the command
     */
    type?: CommandType;
    samplePrompts?: SamplePrompt[];
    /**
     * A relative file path for api response rendering template file. The schema of the file can
     * be referred to in this
     * link:'https://developer.microsoft.com/json-schemas/teams/vDevPreview/MicrosoftTeams.ResponseRenderingTemplate.schema.json'.
     */
    apiResponseRenderingTemplateFile?: string;
    /**
     * Context where the command would apply
     */
    context?: CommandContext[];
    /**
     * Title of the command.
     */
    title: string;
    /**
     * Description of the command.
     */
    description?: string;
    /**
     * A boolean value that indicates if the command should be run once initially with no
     * parameter.
     */
    initialRun?: boolean;
    /**
     * A boolean value that indicates if it should fetch task module dynamically
     */
    fetchTask?: boolean;
    parameters?: ParameterClass[];
    /**
     * Task module to be launched when fetch task set to false.
     */
    taskInfo?: TaskInfo;
    /**
     * semantic description of the command. This is typically meant for consumption by the large
     * language model.
     */
    semanticDescription?: string;
}
export type CommandContext = "compose" | "commandBox" | "message";
export interface ParameterClass {
    /**
     * Name of the parameter.
     */
    name: string;
    /**
     * Type of the parameter
     */
    inputType?: InputType;
    /**
     * Indicates whether this parameter is required or not. By default, it is not.
     */
    isRequired?: boolean;
    /**
     * Title of the parameter.
     */
    title: string;
    /**
     * Description of the parameter.
     */
    description?: string;
    /**
     * Initial value for the parameter
     */
    value?: string;
    /**
     * The choice options for the parameter
     */
    choices?: Choice[];
    /**
     * semantic description of the parameter. This is typically meant for consumption by the
     * large language model.
     */
    semanticDescription?: string;
}
export interface Choice {
    /**
     * Title of the choice
     */
    title: string;
    /**
     * Value of the choice
     */
    value: string;
}
/**
 * Type of the parameter
 */
export type InputType = "text" | "textarea" | "number" | "date" | "time" | "toggle" | "choiceset";
export interface SamplePrompt {
    /**
     * This string will hold the sample prompt
     */
    text: string;
}
/**
 * Type of the command
 */
export type CommandType = "query" | "action";
/**
 * Type of the compose extension.
 */
export type ComposeExtensionType = "botBased" | "apiBased";
export interface MessageHandler {
    /**
     * Type of the message handler
     */
    type: "link";
    value: ValueObject;
}
/**
 * Type of the message handler
 */
export interface ValueObject {
    /**
     * A list of domains that the link message handler can register for, and when they are
     * matched the app will be invoked
     */
    domains?: string[];
    /**
     * A boolean value that indicates whether the app's link message handler supports anonymous
     * invoke flow. [Deprecated]. This property has been superceded by
     * 'supportsAnonymizedPayloads'.
     */
    supportsAnonymousAccess?: boolean;
    /**
     * A boolean value that indicates whether the app's link message handler supports anonymous
     * invoke flow.
     */
    supportsAnonymizedPayloads?: boolean;
    [property: string]: any;
}
export type ConfigurableProperty = "name" | "shortDescription" | "longDescription" | "smallImageUrl" | "largeImageUrl" | "accentColor" | "developerUrl" | "privacyUrl" | "termsOfUseUrl";
export interface ConfigurableTab {
    /**
     * A unique identifier for the tab. This id must be unique within the app manifest.
     */
    id?: string;
    /**
     * The url to use when configuring the tab.
     */
    configurationUrl: string;
    /**
     * A value indicating whether an instance of the tab's configuration can be updated by the
     * user after creation.
     */
    canUpdateConfiguration?: boolean;
    /**
     * Specifies whether the tab offers an experience in the context of a channel in a team, in
     * a 1:1 or group chat, or in an experience scoped to an individual user alone. These
     * options are non-exclusive. Currently, configurable tabs are only supported in the teams
     * and groupchats scopes.
     */
    scopes: ConfigurableTabScope[];
    /**
     * The set of meetingSurfaceItem scopes that a tab belong to
     */
    meetingSurfaces?: MeetingSurface[];
    /**
     * The set of contextItem scopes that a tab belong to
     */
    context?: ConfigurableTabContext[];
    /**
     * The set of supportedPlatform scopes that a tab belong to
     */
    supportedPlatform?: SupportedPlatform[];
    /**
     * A relative file path to a tab preview image for use in SharePoint. Size 1024x768.
     */
    sharePointPreviewImage?: string;
    /**
     * Defines how your tab will be made available in SharePoint.
     */
    supportedSharePointHosts?: SupportedSharePointHost[];
}
export type ConfigurableTabContext = "personalTab" | "channelTab" | "privateChatTab" | "meetingChatTab" | "meetingDetailsTab" | "meetingSidePanel" | "meetingStage" | "callingSidePanel";
export type MeetingSurface = "sidePanel" | "stage";
export type ConfigurableTabScope = "team" | "groupChat";
export type SupportedPlatform = "desktop" | "mobile" | "teamsMeetingDevices";
export type SupportedSharePointHost = "sharePointFullPage" | "sharePointWebPart";
export interface Connector {
    /**
     * A unique identifier for the connector which matches its ID in the Connectors Developer
     * Portal.
     */
    connectorId: string;
    /**
     * The url to use for configuring the connector using the inline configuration experience.
     */
    configurationUrl?: string;
    /**
     * Specifies whether the connector offers an experience in the context of a channel in a
     * team, or an experience scoped to an individual user alone. Currently, only the team scope
     * is supported.
     */
    scopes: "team"[];
}
export interface CopilotAgents {
    /**
     * An array of declarative agent elements references. Currently, only one declarative agent
     * per application is supported.
     */
    declarativeAgents?: DeclarativeAgentRef[];
    /**
     * An array of Custom Engine Agents. Currently only one Custom Engine Agent per application
     * is supported.
     */
    customEngineAgents?: CustomEngineAgent[];
}
export interface CustomEngineAgent {
    /**
     * The id of the Custom Engine Agent. If it is of type bot, the id must match the id
     * specified in a bot in the bots node and the referenced bot must have personal scope. The
     * app short name and short description must also be defined.
     */
    id: string;
    /**
     * The type of the Custom Engine Agent. Currently only type bot is supported.
     */
    type: "bot";
    disclaimer?: Disclaimer;
    /**
     * Possible values: 'agenticUserOnly', 'agentOnly', or 'agentOrAgenticUser'.
     * 'agenticUserOnly' means the customEngineAgent must be hired and cannot be installed as a
     * regular agent. 'agentOrAgenticUser' means the customEngineAgent supports both being
     * installed as a regular agent and being hired. 'agentOnly' means it supports being
     * installed as a regular agent only (default).
     */
    functionsAs?: FunctionsAs;
    /**
     * Unique identifier for the agentic user template. This id must match the id specified in
     * an agentic user template in the agenticUserTemplates node
     */
    agenticUserTemplateId?: string;
}
export interface Disclaimer {
    /**
     * The message shown to users before they interact with this application.
     */
    text: string;
    [property: string]: any;
}
/**
 * Possible values: 'agenticUserOnly', 'agentOnly', or 'agentOrAgenticUser'.
 * 'agenticUserOnly' means the customEngineAgent must be hired and cannot be installed as a
 * regular agent. 'agentOrAgenticUser' means the customEngineAgent supports both being
 * installed as a regular agent and being hired. 'agentOnly' means it supports being
 * installed as a regular agent only (default).
 */
export type FunctionsAs = "agentOnly" | "agenticUserOnly" | "agentOrAgenticUser";
/**
 * The type of the Custom Engine Agent. Currently only type bot is supported.
 *
 * The content of the dashboard card is sourced from a bot.
 */
/**
 * A reference to a declarative agent element. The element's definition is in a separate
 * file.
 */
export interface DeclarativeAgentRef {
    /**
     * A unique identifier for this declarative agent element.
     */
    id: string;
    /**
     * Relative file path to this declarative agent element file in the application package.
     */
    file: string;
}
/**
 * Cards wich could be pinned to dashboard providing summarized view of information relevant
 * to user.
 */
export interface DashboardCard {
    /**
     * Unique Id for the card. Must be unique inside the app.
     */
    id: string;
    /**
     * Represents the name of the card. Maximum length is 255 characters.
     */
    displayName: string;
    /**
     * Description of the card.Maximum length is 255 characters.
     */
    description: string;
    /**
     * Id of the group in the card picker. This must be guid.
     */
    pickerGroupId: string;
    icon?: DashboardCardIcon;
    contentSource: DashboardCardContentSource;
    /**
     * Rendering Size for dashboard card.
     */
    defaultSize: DefaultSize;
}
/**
 * Represents a configuration for the source of the card’s content.
 */
export interface DashboardCardContentSource {
    /**
     * The content of the dashboard card is sourced from a bot.
     */
    sourceType?: "bot";
    /**
     * The configuration for the bot source. Required if sourceType is set to bot.
     */
    botConfiguration?: BotConfiguration;
}
/**
 * The configuration for the bot source. Required if sourceType is set to bot.
 */
export interface BotConfiguration {
    /**
     * The unique Microsoft app ID for the bot as registered with the Bot Framework.
     */
    botId?: string;
}
/**
 * Rendering Size for dashboard card.
 */
export type DefaultSize = "medium" | "large";
/**
 * Represents a configuration for the source of the card’s content
 */
export interface DashboardCardIcon {
    /**
     * The icon for the card, to be displayed in the toolbox and card bar, represented as URL.
     */
    iconUrl?: string;
    /**
     * Office UI Fabric/Fluent UI icon friendly name for the card. This value will be used if
     * ‘iconUrl’ is not specified.
     */
    officeUIFabricIconName?: string;
}
/**
 * When a group install scope is selected, this will define the default capability when the
 * user installs the app
 */
export interface DefaultGroupCapability {
    /**
     * When the install scope selected is Team, this field specifies the default capability
     * available
     */
    team?: Groupchat;
    /**
     * When the install scope selected is GroupChat, this field specifies the default capability
     * available
     */
    groupchat?: Groupchat;
    /**
     * When the install scope selected is Meetings, this field specifies the default capability
     * available
     */
    meetings?: Groupchat;
}
/**
 * When the install scope selected is GroupChat, this field specifies the default capability
 * available
 *
 * When the install scope selected is Meetings, this field specifies the default capability
 * available
 *
 * When the install scope selected is Team, this field specifies the default capability
 * available
 */
export type Groupchat = "tab" | "bot" | "connector";
/**
 * The install scope defined for this app by default. This will be the option displayed on
 * the button when a user tries to add the app
 */
export type DefaultInstallScope = "personal" | "team" | "groupChat" | "meetings" | "copilot";
export interface Description {
    /**
     * A short description of the app used when space is limited. Maximum length is 80
     * characters.
     */
    short: string;
    /**
     * The full description of the app. Maximum length is 4000 characters.
     */
    full: string;
    /**
     * Array of features sections describing what the app can do.
     */
    features?: Feature[];
}
export interface Feature {
    /**
     * Title of the feature the app provides.
     */
    title: string;
    /**
     * Detailed description of the specific feature.
     */
    description: string;
}
export interface Developer {
    /**
     * The display name for the developer.
     */
    name: string;
    /**
     * The Microsoft Partner Network ID that identifies the partner organization building the
     * app. This field is not required, and should only be used if you are already part of the
     * Microsoft Partner Network. More info at https://aka.ms/partner
     */
    mpnId?: string;
    /**
     * The url to the page that provides support information for the app.
     */
    websiteUrl: string;
    /**
     * The url to the page that provides privacy information for the app.
     */
    privacyUrl: string;
    /**
     * The url to the page that provides the terms of use for the app.
     */
    termsOfUseUrl: string;
    /**
     * App developer contact information.
     */
    contactInfo?: ContactInfo;
}
/**
 * App developer contact information.
 */
export interface ContactInfo {
    /**
     * Support configuration.
     */
    defaultSupport: DefaultSupport;
    [property: string]: any;
}
/**
 * Support configuration.
 */
export interface DefaultSupport {
    /**
     * User email for chat support contacts.
     */
    userEmailsForChatSupport: string[];
    /**
     * Email address for email support.
     */
    emailsForEmailSupport: string[];
    [property: string]: any;
}
export type DevicePermission = "geolocation" | "media" | "notifications" | "midi" | "openExternal";
export interface ElementRelationshipSet {
    /**
     * An array containing multiple instances of unidirectional dependency relationships (each
     * represented by a oneWayDependency object).
     */
    oneWayDependencies?: OneWayDependency[];
    /**
     * An array containing multiple instances of mutual dependency relationships between
     * elements (each represented by a mutualDependency object).
     */
    mutualDependencies?: Array<ElementReference[]>;
}
/**
 * A specific instance of mutual dependency between two or more elements, indicating that
 * each element depends on the others in a bidirectional manner.
 */
export interface ElementReference {
    name: MutualDependencyName;
    id: string;
    commandIds?: string[];
}
export type MutualDependencyName = "bots" | "staticTabs" | "composeExtensions" | "configurableTabs";
/**
 * An object representing a unidirectional dependency relationship, where one specific
 * element (referred to as the `element`) relies on an array of other elements (referred to
 * as the `dependsOn`) in a single direction.
 */
export interface OneWayDependency {
    element: ElementReference;
    dependsOn: ElementReference[];
}
/**
 * The set of extensions for this app. Currently only one extensions per app is supported.
 */
export interface ElementExtension {
    requirements?: RequirementsExtensionElement;
    /**
     * General runtime for "MailApp" or "TaskpaneApp". Configures the set of runtimes and
     * actions that can be used by each extension point. Min size 1.
     */
    runtimes?: ExtensionRuntimesArray[];
    ribbons?: ExtensionRibbonsArray[];
    autoRunEvents?: ExtensionAutoRunEventsArray[];
    alternates?: ExtensionAlternateVersionsArray[];
    /**
     * The url for your extension, used to validate Exchange user identity tokens.
     */
    audienceClaimUrl?: string;
    appDeeplinks?: ExtensionAppDeeplinksArray[];
    contentRuntimes?: ExtensionContentRuntimeArray[];
    getStartedMessages?: ExtensionGetStartedMessageArray[];
    /**
     * Specifies the context menus for your extension. A context menu is a shortcut menu that
     * appears when a user right-clicks (selects and holds) in the Office UI. Min size 1.
     */
    contextMenus?: ExtensionContextMenuArray[];
    /**
     * Keyboard shortcuts, also known as key combinations, enable your add-in's users to work
     * more efficiently. Keyboard shortcuts also improve the add-in's accessibility for users
     * with disabilities by providing an alternative to the mouse.
     */
    keyboardShortcuts?: ExtensionKeyboardShortcut[];
}
export interface ExtensionAlternateVersionsArray {
    requirements?: RequirementsExtensionElement;
    prefer?: Prefer;
    hide?: Hide;
    alternateIcons: AlternateIcons;
}
export interface AlternateIcons {
    icon: ExtensionCommonIcon;
    highResolutionIcon: ExtensionCommonIcon;
}
export interface ExtensionCommonIcon {
    /**
     * Size in pixels of the icon. Three image sizes are required (16, 32, and 80 pixels)
     */
    size: number;
    /**
     * Absolute Url to the icon.
     */
    url: string;
}
export interface Hide {
    storeOfficeAddin?: StoreOfficeAddin;
    customOfficeAddin?: CustomOfficeAddin;
    /**
     * Configures how to hide windows native extensions
     */
    windowsExtensions?: WindowsExtensions;
    [property: string]: any;
}
export interface CustomOfficeAddin {
    /**
     * Solution ID of the in-market add-in to hide. Maximum length is 64 characters.
     */
    officeAddinId: string;
}
export interface StoreOfficeAddin {
    /**
     * Solution ID of an in-market add-in to hide. Maximum length is 64 characters.
     */
    officeAddinId: string;
    /**
     * Asset ID of the in-market add-in to hide. Maximum length is 64 characters.
     */
    assetId: string;
}
/**
 * Configures how to hide windows native extensions
 */
export interface WindowsExtensions {
    /**
     * Specifies the effect to take while installing the web add-in if the equivalent add-in is
     * installed.
     */
    effect: Effect;
    /**
     * Specifies the equivalent COM or VSTO add-ins
     */
    comAddin?: WindowsExtensionsCOMAddin;
    /**
     * Specifies the equivalent automation add-ins
     */
    automationAddin?: AutomationAddin;
    /**
     * Specifies the XLL-based add-ins custom function
     */
    xllCustomFunctions?: XllCustomFunctions;
}
/**
 * Specifies the equivalent automation add-ins
 */
export interface AutomationAddin {
    /**
     * Specifies the program Ids of the equivalent automation add-ins
     */
    progIds: string[];
}
/**
 * Specifies the equivalent COM or VSTO add-ins
 */
export interface WindowsExtensionsCOMAddin {
    /**
     * Specifies the program Ids of the equivalent COM add-ins and the names of equivalent VSTO
     * add-ins
     */
    progIds: string[];
}
/**
 * Specifies the effect to take while installing the web add-in if the equivalent add-in is
 * installed.
 */
export type Effect = "userOptionToDisable" | "disableWithNotification";
/**
 * Specifies the XLL-based add-ins custom function
 */
export interface XllCustomFunctions {
    /**
     * Specifies the file names of the XLL-based add-ins custom function
     */
    fileNames: string[];
}
export interface Prefer {
    comAddin?: PreferCOMAddin;
    xllCustomFunctions?: ExtensionXllCustomFunctions;
    [property: string]: any;
}
export interface PreferCOMAddin {
    /**
     * Program ID of the alternate com extension. Maximum length is 64 characters.
     */
    progId: string;
}
export interface ExtensionXllCustomFunctions {
    fileName?: string;
    [property: string]: any;
}
/**
 * Specifies limitations on which clients the add-in can be installed on, including
 * limitations on the Office host application, the form factors, and the requirement sets
 * that the client must support.
 *
 * Specifies the Office requirement sets.
 */
export interface RequirementsExtensionElement {
    capabilities?: Capability[];
    /**
     * Identifies the scopes in which the add-in can run. For example, mail means Outlook.
     */
    scopes?: RequirementsScope[];
    /**
     * Identifies the form factors that support the add-in. Supported values: mobile, desktop.
     */
    formFactors?: FormFactor[];
}
export interface Capability {
    /**
     * Identifies the name of the requirement sets that the add-in needs to run.
     */
    name: string;
    /**
     * Identifies the minimum version for the requirement sets that the add-in needs to run.
     */
    minVersion?: string;
    /**
     * Identifies the maximum version for the requirement sets that the add-in needs to run.
     */
    maxVersion?: string;
}
export type FormFactor = "desktop" | "mobile";
export type RequirementsScope = "mail" | "workbook" | "document" | "presentation";
/**
 * Represents the copilot extension point
 */
export interface ExtensionAppDeeplinksArray {
    requirements?: AppDeeplinkRequirements;
    contexts: ExtensionContext[];
    /**
     * The ID of an action defined in runtimes. Manifest should be invalidated if no action with
     * an id matching actionId is present in runtimes.
     */
    actionId: string;
    /**
     * the text that will be shown on the app as a clickable item.
     */
    label: string;
    /**
     * the text metadata, for recommendation engine.
     */
    semanticDescription: string;
}
/**
 * Specifies the Office application windows in which the ribbon customization is available
 * to the user. Each item in the array is a member of a string array. Possible values are:
 * mailRead, mailCompose, meetingDetailsOrganizer, meetingDetailsAttendee,
 * onlineMeetingDetailsOrganizer, logEventMeetingDetailsAttendee, spamReportingOverride.
 */
export type ExtensionContext = "mailRead" | "mailCompose" | "meetingDetailsOrganizer" | "meetingDetailsAttendee" | "onlineMeetingDetailsOrganizer" | "logEventMeetingDetailsAttendee" | "default" | "spamReportingOverride";
/**
 * Specifies limitations on which clients the add-in can be installed on, including
 * limitations on the Office host application, the form factors, and the requirement sets
 * that the client must support.
 *
 * Specifies the Office requirement sets.
 */
export interface AppDeeplinkRequirements {
    capabilities?: Capability[];
    /**
     * Identifies the scopes in which the add-in can run. For example, mail means Outlook.
     */
    scopes?: RequirementsScope[];
    /**
     * Identifies the form factors that support the add-in. Supported values: mobile, desktop.
     */
    formFactors?: FormFactor[];
}
export interface ExtensionAutoRunEventsArray {
    requirements?: RequirementsExtensionElement;
    /**
     * Specifies the type of event. For supported types, please see:
     * https://learn.microsoft.com/en-us/office/dev/add-ins/outlook/autolaunch?tabs=xmlmanifest#supported-events.
     */
    events: Event[];
}
export interface Event {
    type: string;
    /**
     * The ID of an action defined in runtimes. Maximum length is 64 characters.
     */
    actionId: string;
    /**
     * Configures how Outlook responds to the event.
     */
    options?: Options;
}
/**
 * Configures how Outlook responds to the event.
 */
export interface Options {
    sendMode: SendMode;
}
export type SendMode = "promptUser" | "softBlock" | "block";
/**
 * Content runtime is for 'ContentApp', which can be embedded directly into Excel or
 * PowerPoint documents.
 */
export interface ExtensionContentRuntimeArray {
    requirements?: ContentRuntimeRequirements;
    /**
     * A unique identifier for this runtime within the app. This is developer specified.
     */
    id: string;
    code: ExtensionRuntimeCode;
    /**
     * The desired height in pixels for the initial content placeholder. This value MUST be
     * between 32 and 1000 pixels. Default value will be determined by host.
     */
    requestedHeight?: number;
    /**
     * The desired width in pixels for the initial content placeholder. This value MUST be
     * between 32 and 1000 pixels. Default value will be determined by host.
     */
    requestedWidth?: number;
    /**
     * Specifies whether a snapshot image of your content add-in is saved with the host
     * document. Default value is false. Set true to disable.
     */
    disableSnapshot?: boolean;
}
export interface ExtensionRuntimeCode {
    /**
     * URL of the .html page to be loaded in browser-based runtimes.
     */
    page: string;
    /**
     * URL of the .js script file to be loaded in UI-less runtimes.
     */
    script?: string;
}
/**
 * Specifies limitations on which clients the add-in can be installed on, including
 * limitations on the Office host application, the form factors, and the requirement sets
 * that the client must support.
 *
 * Specifies the Office requirement sets.
 */
export interface ContentRuntimeRequirements {
    capabilities?: Capability[];
    /**
     * Identifies the scopes in which the add-in can run. For example, mail means Outlook.
     */
    scopes?: RequirementsScope[];
    /**
     * Identifies the form factors that support the add-in. Supported values: mobile, desktop.
     */
    formFactors?: FormFactor[];
}
/**
 * Specifies the context menus for your extension. A context menu is a shortcut menu that
 * appears when a user right-clicks (selects and holds) in the Office UI. Min size 1.
 */
export interface ExtensionContextMenuArray {
    requirements?: ContextMenuRequirements;
    /**
     * Configures the context menus. Minimum size is 1.
     */
    menus: ExtensionMenuItem[];
}
/**
 * Configures the context menus. Minimum size is 1.
 *
 * The title used for the top of the callout.
 */
export interface ExtensionMenuItem {
    /**
     * Use 'text' or 'cell' here for Office context menu. Use text if the context menu should
     * open when a user right-clicks (selects and holds) on the selected text. Use cell if the
     * context menu should open when the user right-clicks (selects and holds) on a cell in an
     * Excel spreadsheet.
     */
    entryPoint: EntryPoint;
    controls: ExtensionCommonCustomGroupControlsItem[];
}
export interface ExtensionCommonCustomGroupControlsItem {
    /**
     * A unique identifier for this control within the app. Maximum length is 64 characters.
     */
    id: string;
    /**
     * Defines the type of control whether button or menu.
     */
    type: PurpleType;
    /**
     * Id of an existing office control. Maximum length is 64 characters.
     */
    builtInControlId?: string;
    /**
     * Displayed text for the control. Maximum length is 64 characters.
     */
    label: string;
    /**
     * Configures the icons for the custom control.
     */
    icons: ExtensionCommonIcon[];
    supertip: ExtensionCommonSuperToolTip;
    /**
     * The ID of an execution-type action that handles this key combination. Maximum length is
     * 64 characters.
     */
    actionId?: string;
    /**
     * Specifies whether a group, button, menu, or menu item will be hidden on application and
     * platform combinations that support the API (Office.ribbon.requestCreateControls) that
     * installs custom contextual tabs on the ribbon. Default is false.
     */
    overriddenByRibbonApi?: boolean;
    /**
     * Whether the control is initially enabled.
     */
    enabled?: boolean;
    /**
     * Configures the items for a menu control.
     */
    items?: ExtensionCommonCustomControlMenuItem[];
    /**
     * KeyTip shortcut for keyboard navigation (1-3 uppercase alphanumeric characters)
     */
    keytip?: string;
}
export interface ExtensionCommonCustomControlMenuItem {
    /**
     * A unique identifier for this control within the app. Maximum length is 64 characters.
     */
    id: string;
    /**
     * Supported values: menuItem.
     */
    type: "menuItem";
    /**
     * Displayed text for the control. Maximum length is 64 characters.
     */
    label: string;
    icons?: ExtensionCommonIcon[];
    supertip: ExtensionCommonSuperToolTip;
    /**
     * The ID of an action defined in runtimes. Maximum length is 64 characters.
     */
    actionId: string;
    /**
     * Whether the control is initially enabled.
     */
    enabled?: boolean;
    overriddenByRibbonApi?: boolean;
    /**
     * KeyTip shortcut for keyboard navigation (1-3 uppercase alphanumeric characters)
     */
    keytip?: string;
}
export interface ExtensionCommonSuperToolTip {
    /**
     * Title text of the super tip. Maximum length is 64 characters.
     */
    title: string;
    /**
     * Description of the super tip. Maximum length is 250 characters.
     */
    description: string;
}
/**
 * Supported values: menuItem.
 */
/**
 * Defines the type of control whether button or menu.
 */
export type PurpleType = "button" | "menu";
/**
 * Use 'text' or 'cell' here for Office context menu. Use text if the context menu should
 * open when a user right-clicks (selects and holds) on the selected text. Use cell if the
 * context menu should open when the user right-clicks (selects and holds) on a cell in an
 * Excel spreadsheet.
 */
export type EntryPoint = "text" | "cell";
/**
 * Specifies limitations on which clients the add-in can be installed on, including
 * limitations on the Office host application, the form factors, and the requirement sets
 * that the client must support.
 *
 * Specifies the Office requirement sets.
 */
export interface ContextMenuRequirements {
    capabilities?: Capability[];
    /**
     * Identifies the scopes in which the add-in can run. For example, mail means Outlook.
     */
    scopes?: RequirementsScope[];
    /**
     * Identifies the form factors that support the add-in. Supported values: mobile, desktop.
     */
    formFactors?: FormFactor[];
}
/**
 * Provides information used by the callout that appears when the add-in is installed.
 */
export interface ExtensionGetStartedMessageArray {
    requirements?: GetStartedMessageRequirements;
    /**
     * The title used for the top of the callout.
     */
    title: string;
    /**
     * The description/body content for the callout.
     */
    description: string;
    /**
     * A URL to a page that explains the add-in in detail.
     */
    learnMoreUrl: string;
}
/**
 * Specifies limitations on which clients the add-in can be installed on, including
 * limitations on the Office host application, the form factors, and the requirement sets
 * that the client must support.
 *
 * Specifies the Office requirement sets.
 */
export interface GetStartedMessageRequirements {
    capabilities?: Capability[];
    /**
     * Identifies the scopes in which the add-in can run. For example, mail means Outlook.
     */
    scopes?: RequirementsScope[];
    /**
     * Identifies the form factors that support the add-in. Supported values: mobile, desktop.
     */
    formFactors?: FormFactor[];
}
export interface ExtensionKeyboardShortcut {
    /**
     * Specifies the Office requirement sets.
     */
    requirements?: RequirementsExtensionElement;
    /**
     * Array of mappings from actions to the key combinations that invoke the actions.
     */
    shortcuts: ExtensionShortcut[];
    /**
     * Specifies the full URLs for shortcuts mapping and localization resource files that don't
     * directly support the unified manifest.
     */
    keyMappingFiles?: KeyboardShortcutsMappingFiles;
    [property: string]: any;
}
/**
 * Specifies the full URLs for shortcuts mapping and localization resource files that don't
 * directly support the unified manifest.
 */
export interface KeyboardShortcutsMappingFiles {
    /**
     * The full URL of the JSON file that will contain the keyboard combination configuration on
     * Office application and platform combinations that don't directly support the unified
     * manifest.
     */
    shortcutsUrl: string;
    /**
     * The full URL of a file that provides supplemental resource, such as localized strings,
     * for the file specified in the shortcutsUrl attribute.
     */
    localizationResourceUrl?: string;
}
export interface ExtensionShortcut {
    key: Key;
    /**
     * The ID of an execution-type action that handles this key combination.
     */
    actionId: string;
    [property: string]: any;
}
/**
 * Key combinations in different platform (i.e. default, windows, web and mac).
 */
export interface Key {
    /**
     * Fallback key for any platform that isn't specified.
     */
    default: string;
    /**
     * key for mac platform. Alt is mapped to the Option key.
     */
    mac?: string;
    /**
     * key for web platform.
     */
    web?: string;
    /**
     * key for windows platform. Command is mapped to the Ctrl key.
     */
    windows?: string;
    [property: string]: any;
}
export interface ExtensionRibbonsArray {
    requirements?: RequirementsExtensionElement;
    contexts?: ExtensionContext[];
    tabs: ExtensionRibbonsArrayTabsItem[];
    fixedControls?: ExtensionRibbonsArrayFixedControlItem[];
    spamPreProcessingDialog?: ExtensionRibbonsSpamPreProcessingDialog;
}
export interface ExtensionRibbonsArrayFixedControlItem {
    /**
     * A unique identifier for this control within the app. Maximum length is 64 characters.
     */
    id: string;
    /**
     * Defines the type of control.
     */
    type: "button";
    /**
     * Displayed text for the control. Maximum length is 64 characters.
     */
    label: string;
    icons: ExtensionCommonIcon[];
    supertip: ExtensionCommonSuperToolTip;
    /**
     * The ID of an execution-type action that handles this key combination. Maximum length is
     * 64 characters.
     */
    actionId: string;
    /**
     * Whether the control is initially enabled.
     */
    enabled: boolean;
}
/**
 * Defines the type of control.
 */
export interface ExtensionRibbonsSpamPreProcessingDialog {
    /**
     * Specifies the custom title of the preprocessing dialog.
     */
    title: string;
    /**
     * Specifies the custom text that appears in the preprocessing dialog.
     */
    description: string;
    /**
     * Indicating if the developer will allow the user to permanently bypass the PreProcessing
     * Dialog for this add-in. "false" is the default value if not specified.
     */
    spamNeverShowAgainOption?: boolean;
    /**
     * Specifies up to five options that a user can select from the preprocessing dialog to
     * provide a reason for reporting a message.
     */
    spamReportingOptions?: SpamReportingOptions;
    /**
     * A text box to the preprocessing dialog to allow users to provide additional information
     * on the message they're reporting. This value is the title of that text box.
     */
    spamFreeTextSectionTitle?: string;
    /**
     * Specifies the custom text and URL to provide informational resources to the users.
     */
    spamMoreInfo?: SpamMoreInfo;
}
/**
 * Specifies the custom text and URL to provide informational resources to the users.
 */
export interface SpamMoreInfo {
    /**
     * Specifies display content of the hyperlink pointing to the site containing informational
     * resources in the preprocessing dialog of a spam-reporting add-in.
     */
    text: string;
    /**
     * Specifies the URL of the hyperlink pointing to the site containing informational
     * resources in the preprocessing dialog of a spam-reporting add-in.
     */
    url: string;
    [property: string]: any;
}
/**
 * Specifies up to five options that a user can select from the preprocessing dialog to
 * provide a reason for reporting a message.
 */
export interface SpamReportingOptions {
    /**
     * Specifies the title listed before the reporting options list.
     */
    title: string;
    /**
     * Specifies the custom options that a user can select from the preprocessing dialog to
     * provide a reason for reporting a message.
     */
    options: string[];
    /**
     * Can be set to "radio" or "checkbox". This determines if Radio Buttons or checkboxes are
     * used for the options. "checkbox" is the default if this value is not specified.
     */
    type?: SpamReportingOptionsType;
    [property: string]: any;
}
/**
 * Can be set to "radio" or "checkbox". This determines if Radio Buttons or checkboxes are
 * used for the options. "checkbox" is the default if this value is not specified.
 */
export type SpamReportingOptionsType = "radio" | "checkbox";
export interface ExtensionRibbonsArrayTabsItem {
    /**
     * A unique identifier for this tab within the app. Maximum length is 64 characters.
     */
    id?: string;
    /**
     * Displayed text for the tab. Maximum length is 64 characters.
     */
    label?: string;
    position?: Position;
    /**
     * Id of the existing office Tab. Maximum length is 64 characters.
     */
    builtInTabId?: string;
    /**
     * Defines tab groups.
     */
    groups?: ExtensionRibbonsCustomTabGroupsItem[];
    /**
     * Defines mobile group item.
     */
    customMobileRibbonGroups?: ExtensionRibbonsCustomMobileGroupItem[];
    /**
     * KeyTip shortcut for keyboard navigation (1-3 uppercase alphanumeric characters)
     */
    keytip?: string;
}
export interface ExtensionRibbonsCustomMobileGroupItem {
    /**
     * Specify the Id of the group. Used for mobileMessageRead ext point.
     */
    id: string;
    /**
     * Short label of the control. Maximum length is 32 characters.
     */
    label: string;
    controls: ExtensionRibbonsCustomMobileControlButtonItem[];
    [property: string]: any;
}
export interface ExtensionRibbonsCustomMobileControlButtonItem {
    /**
     * Specify the Id of the button like msgReadFunctionButton.
     */
    id: string;
    type: "mobileButton";
    /**
     * Short label of the control. Maximum length is 32 characters.
     */
    label: string;
    icons: ExtensionCustomMobileIcon[];
    /**
     * The ID of an action defined in runtimes. Maximum length is 64 characters.
     */
    actionId: string;
    [property: string]: any;
}
export interface ExtensionCustomMobileIcon {
    /**
     * Size in pixels of the icon. Three image sizes are required (25, 32, and 48 pixels).
     */
    size: number;
    /**
     * Url to the icon.
     */
    url: string;
    /**
     * How to scale - 1,2,3 for each image. This attribute specifies the UIScreen.scale property
     * for iOS devices.
     */
    scale: number;
}
export interface ExtensionRibbonsCustomTabGroupsItem {
    /**
     * A unique identifier for this group within the app. Maximum length is 64 characters.
     */
    id?: string;
    /**
     * Displayed text for the group. Maximum length is 64 characters.
     */
    label?: string;
    icons?: ExtensionCommonIcon[];
    controls?: ExtensionCommonCustomGroupControlsItem[];
    /**
     * Id of a built-in Group. Maximum length is 64 characters.
     */
    builtInGroupId?: string;
    /**
     * Specifies whether a group will be hidden on application and platform combinations that
     * support the API (Office.ribbon.requestCreateControls) that installs custom contextual
     * tabs on the ribbon. Default is false.
     */
    overriddenByRibbonApi?: boolean;
}
export interface Position {
    /**
     * The id of the built-in tab. Maximum length is 64 characters.
     */
    builtInTabId: string;
    /**
     * Define alignment of this custom tab relative to the specified built-in tab.
     */
    align: Align;
}
/**
 * Define alignment of this custom tab relative to the specified built-in tab.
 */
export type Align = "after" | "before";
/**
 * General runtime for "MailApp" or "TaskpaneApp". Configures the set of runtimes and
 * actions that can be used by each extension point. Min size 1.
 *
 * A runtime environment for a page or script.
 */
export interface ExtensionRuntimesArray {
    requirements?: RequirementsExtensionElement;
    /**
     * A unique identifier for this runtime within the app.  Maximum length is 64 characters.
     */
    id: string;
    /**
     * Supports running functions and launching pages.
     */
    type?: "general";
    code: ExtensionRuntimeCode;
    /**
     * Runtimes with a short lifetime do not preserve state across executions. Runtimes with a
     * long lifetime do.
     */
    lifetime?: Lifetime;
    actions?: ExtensionRuntimesActionsItem[];
    customFunctions?: ExtensionCustomFunctions;
}
/**
 * Specifies the set of actions supported by this runtime. An action is either running a
 * JavaScript function or opening a view such as a task pane.
 */
export interface ExtensionRuntimesActionsItem {
    /**
     * Identifier for this action. Maximum length is 64 characters. This value is passed to the
     * code file.
     */
    id: string;
    /**
     * executeFunction: Run a script function without waiting for it to finish. openPage: Open a
     * page in a view. executeDataFunction: invoke command and retrieve data.
     */
    type: ActionType;
    /**
     * Display name of the action. Maximum length is 64 characters.
     */
    displayName?: string;
    /**
     * Specifies that a task pane supports pinning, which keeps the task pane open when the user
     * changes the selection.
     */
    pinnable?: boolean;
    /**
     * View where the page should be opened. Maximum length is 64 characters.
     */
    view?: string;
    /**
     * Whether allows the action to have multiple selection.
     */
    multiselect?: boolean;
    /**
     * Whether allows task pane add-ins to activate without the Reading Pane enabled or a
     * message selected.
     */
    supportsNoItemContext?: boolean;
}
/**
 * executeFunction: Run a script function without waiting for it to finish. openPage: Open a
 * page in a view. executeDataFunction: invoke command and retrieve data.
 */
export type ActionType = "executeFunction" | "openPage" | "executeDataFunction";
/**
 * Custom function enable developers to add new functions to Excel by defining those
 * functions in JavaScript as part of an add-in. Users within Excel can access custom
 * functions just as they would any native function in Excel, such as SUM().
 */
export interface ExtensionCustomFunctions {
    /**
     * Array of function object which defines function metadata.
     */
    functions?: ExtensionFunction[];
    namespace?: ExtensionCustomFunctionsNamespace;
    /**
     * Allows a custom function to accept Excel data types as parameters and return values.
     */
    allowCustomDataForDataTypeAny?: boolean;
    /**
     * The full URL of a metadata json file with default locale.
     */
    metadataUrl?: string;
    /**
     * Array of custom defined enum objects.
     */
    enums?: Enum[];
}
export interface Enum {
    /**
     * A unique ID for the enum.
     */
    id: string;
    /**
     * The type of the values in this enum.
     */
    type: EnumType;
    /**
     * Array that defines the constants for the enum.
     */
    values: ValueElement[];
}
/**
 * The type of the values in this enum.
 */
export type EnumType = "number" | "string";
export interface ValueElement {
    /**
     * A brief description of the constant.
     */
    name: string;
    /**
     * When enum type is number, the actual number value of the constant.
     */
    numberValue?: number | null;
    /**
     * When enum type is string, the actual string value of the constant.
     */
    stringValue?: string;
    /**
     * Additional information about the constant, intended to provide more context or details.
     */
    tooltip?: string;
}
export interface ExtensionFunction {
    /**
     * A unique ID for the function.
     */
    id: string;
    /**
     * The name of the function that end users see in Excel. In Excel, this function name is
     * prefixed by the custom functions namespace that's specified in the manifest file.
     */
    name: string;
    /**
     * The description of the function that end users see in Excel.
     */
    description?: string;
    /**
     * URL that provides information about the function. (It is displayed in a task pane.)
     */
    helpUrl?: string;
    /**
     * Array that defines the input parameters for the function.
     */
    parameters: ExtensionFunctionParameter[];
    result: ExtensionResult;
    /**
     * If true, the function can output repeatedly to the cell even when invoked only once. This
     * option is useful for rapidly-changing data sources, such as a stock price. The function
     * should have no return statement. Instead, the result value is passed as the argument of
     * the StreamingInvocation.setResult callback function.
     */
    stream?: boolean;
    /**
     * If true, the function recalculates each time Excel recalculates, instead of only when the
     * formula's dependent values have changed. A function can't use both the stream and
     * volatile properties. If the stream and volatile properties are both set to true, the
     * volatile property will be ignored.
     */
    volatile?: boolean;
    /**
     * If true, Excel calls the CancelableInvocation handler whenever the user takes an action
     * that has the effect of canceling the function; for example, manually triggering
     * recalculation or editing a cell that is referenced by the function. Cancelable functions
     * are typically only used for asynchronous functions that return a single result and need
     * to handle the cancellation of a request for data. A function can't use both the stream
     * and cancelable properties.
     */
    cancelable?: boolean;
    /**
     * If true, your custom function can access the address of the cell that invoked it. The
     * address property of the invocation parameter contains the address of the cell that
     * invoked your custom function. A function can't use both the stream and requiresAddress
     * properties.
     */
    requiresAddress?: boolean;
    /**
     * If true, your custom function can access the addresses of the function's input
     * parameters. This property must be used in combination with the dimensionality property of
     * the result object, and dimensionality must be set to matrix.
     */
    requiresParameterAddress?: boolean;
    /**
     * If `true`, the function can access the address of the cell calling the streaming
     * function. The `address` property of the invocation parameter contains the address of the
     * cell that invoked your streaming function.
     */
    requiresStreamAddress?: boolean;
    /**
     * If `true`, the function can access the parameter addresses of the cell calling the
     * streaming function. The `parameterAddresses` property of the invocation parameter
     * contains the parameter addresses for your streaming function.
     */
    requiresStreamParameterAddresses?: boolean;
    /**
     * If `true`, the data type being referenced by the custom function is passed as the first
     * argument to the custom function.
     */
    capturesCallingObject?: boolean;
    /**
     * If `true`, the custom function will not appear in the formula AutoComplete menu in Excel.
     */
    excludeFromAutoComplete?: boolean;
    /**
     * If `true`, it designates that the function is a linked entity load service that returns
     * linked entity cell values for linked entity IDs requested by Excel.
     */
    linkedEntityLoadService?: boolean;
    [property: string]: any;
}
export interface ExtensionFunctionParameter {
    /**
     * The name of the parameter. This name is displayed in Excel's IntelliSense.
     */
    name: string;
    /**
     * A description of the parameter. This is displayed in Excel's IntelliSense.
     */
    description?: string;
    /**
     * The data type of the parameter. It can only be boolean, number, string, any,
     * CustomFunctions.Invocation, CustomFunctions.StreamingInvocation or
     * CustomFunctions.CancelableInvocation, any allows you to use any of other types.
     */
    type?: string;
    /**
     * A subfield of the type property. Specifies the Excel data types accepted by the custom
     * function. Accepts the values cellvalue, booleancellvalue, doublecellvalue,
     * entitycellvalue, errorcellvalue, linkedentitycellvalue, localimagecellvalue,
     * stringcellvalue, webimagecellvalue
     */
    cellValueType?: CellValueType;
    /**
     * Must be either scalar (a non-array value) or matrix (a 2-dimensional array).
     */
    dimensionality?: Dimensionality;
    /**
     * If true, the parameter is optional.
     */
    optional?: boolean | null;
    /**
     * If true, parameters populate from a specified array. Note that functions all repeating
     * parameters are considered optional parameters by definition.
     */
    repeating?: boolean;
    /**
     * |The `id` of the enum in the `enums` array. This associates the custom enum with the
     * function and enables Excel to display the enum members in the formula AutoComplete menu.
     */
    customEnumId?: string;
    [property: string]: any;
}
/**
 * A subfield of the type property. Specifies the Excel data types accepted by the custom
 * function. Accepts the values cellvalue, booleancellvalue, doublecellvalue,
 * entitycellvalue, errorcellvalue, linkedentitycellvalue, localimagecellvalue,
 * stringcellvalue, webimagecellvalue
 */
export type CellValueType = "cellvalue" | "booleancellvalue" | "doublecellvalue" | "entitycellvalue" | "errorcellvalue" | "linkedentitycellvalue" | "localimagecellvalue" | "stringcellvalue" | "webimagecellvalue";
/**
 * Must be either scalar (a non-array value) or matrix (a 2-dimensional array).
 *
 * Must be either scalar (a non-array value) or matrix (a 2-dimensional array). Default:
 * scalar.
 */
export type Dimensionality = "scalar" | "matrix";
/**
 * Object that defines the type of information that is returned by the function.
 */
export interface ExtensionResult {
    /**
     * Must be either scalar (a non-array value) or matrix (a 2-dimensional array). Default:
     * scalar.
     */
    dimensionality?: Dimensionality;
    [property: string]: any;
}
/**
 * Defines the namespace for your custom functions. A namespace prepends itself to your
 * custom functions to help customers identify your functions as part of your add-in.
 */
export interface ExtensionCustomFunctionsNamespace {
    /**
     * Non-localizeable version of the namespace.
     */
    id: string;
    /**
     * Localizeable version of the namespace.
     */
    name: string;
    [property: string]: any;
}
/**
 * Runtimes with a short lifetime do not preserve state across executions. Runtimes with a
 * long lifetime do.
 */
export type Lifetime = "short" | "long";
/**
 * Supports running functions and launching pages.
 */
/**
 * Specify the app's Graph connector configuration. If this is present then
 * webApplicationInfo.id must also be specified.
 */
export interface GraphConnector {
    /**
     * The url where Graph-connector notifications for the application should be sent.
     */
    notificationUrl: string;
}
export interface Icons {
    /**
     * A relative file path to a transparent PNG outline icon. The border color needs to be
     * white. Size 32x32.
     */
    outline: string;
    /**
     * A relative file path to a full color PNG icon. Size 192x192.
     */
    color: string;
    /**
     * A relative file path to a full color PNG icon with transparent background. Size 32x32.
     */
    color32x32?: string;
}
/**
 * The Intune-related properties for the app.
 */
export interface IntuneInfo {
    /**
     * Supported mobile app managment version that the app is compliant with.
     */
    supportedMobileAppManagementVersion?: string;
}
export interface LocalizationInfo {
    /**
     * The language tag of the strings in this top level manifest file.
     */
    defaultLanguageTag: string;
    /**
     * A relative file path to a the .json file containing strings in the default language.
     */
    defaultLanguageFile?: string;
    additionalLanguages?: AdditionalLanguage[];
}
export interface AdditionalLanguage {
    /**
     * The language tag of the strings in the provided file.
     */
    languageTag: string;
    /**
     * A relative file path to a the .json file containing the translated strings.
     */
    file: string;
}
/**
 * The version of the schema this manifest is using.
 */
export type ManifestVersion = "devPreview" | "m365DevPreview";
/**
 * Specify meeting extension definition.
 */
export interface MeetingExtensionDefinition {
    /**
     * Meeting supported scenes.
     */
    scenes?: Scene[];
    /**
     * Represents if the app has added support for sharing to stage.
     */
    supportsCustomShareToStage?: boolean;
    /**
     * Meeting supported video filters.
     */
    videoFilters?: VideoFilter[];
    /**
     * A URL for configuring the video filters.
     */
    videoFiltersConfigurationUrl?: string;
    /**
     * A boolean value indicating whether this app can stream the meeting's audio video content
     * to an RTMP endpoint.
     */
    supportsStreaming?: boolean;
    /**
     * A boolean value indicating whether this app supports access by anonymous guest users.
     */
    supportsAnonymousGuestUsers?: boolean;
}
export interface Scene {
    /**
     * A unique identifier for this scene. This id must be a GUID.
     */
    id: string;
    /**
     * Scene name.
     */
    name: string;
    /**
     * A relative file path to a scene metadata json file.
     */
    file: string;
    /**
     * A relative file path to a scene PNG preview icon.
     */
    preview: string;
    /**
     * Maximum audiences supported in scene.
     */
    maxAudience: number;
    /**
     * Number of seats reserved for organizers or presenters.
     */
    seatsReservedForOrganizersOrPresenters: number;
}
export interface VideoFilter {
    /**
     * A unique identifier for this video filter. This id must be a GUID.
     */
    id: string;
    /**
     * Video filter's name.
     */
    name: string;
    /**
     * A relative file path to a video filter's thumbnail.
     */
    thumbnail: string;
}
export interface NameClass {
    /**
     * A short display name for the app.
     */
    short: string;
    /**
     * The full name of the app, used if the full app name exceeds 30 characters.
     */
    full: string;
    /**
     * An abbreviated name for the app.
     */
    abbreviated?: string;
}
export type Permission = "identity" | "messageTeamMembers";
export interface ScopeConstraints {
    /**
     * A list of team thread ids to which your app is restricted to
     */
    teams?: TeamElement[];
    /**
     * A list of chat thread ids to which your app is restricted to
     */
    groupChats?: GroupChatElement[];
}
export interface GroupChatElement {
    /**
     * Chat's thread Id
     */
    id: string;
}
export interface TeamElement {
    /**
     * Team's thread Id
     */
    id: string;
}
export interface StaticTab {
    /**
     * A unique identifier for the entity which the tab displays.
     */
    entityId: string;
    /**
     * The display name of the tab.
     */
    name?: string;
    /**
     * The url which points to the entity UI to be displayed in the Teams canvas.
     */
    contentUrl?: string;
    /**
     * The Microsoft App ID specified for the bot in the Bot Framework portal
     * (https://dev.botframework.com/bots)
     */
    contentBotId?: string;
    /**
     * The url to point at if a user opts to view in a browser.
     */
    websiteUrl?: string;
    /**
     * The url to direct a user's search queries.
     */
    searchUrl?: string;
    /**
     * Specifies whether the tab offers an experience in the context of a channel in a team, or
     * an experience scoped to an individual user alone or a group chat. These options are
     * non-exclusive. Currently static tabs are only supported in the 'personal' scope.
     */
    scopes: StaticTabScope[];
    /**
     * The set of contextItem scopes that a tab belong to
     */
    context?: StaticTabContext[];
    /**
     * The set of supportedPlatform scopes that a tab belong to
     */
    supportedPlatform?: SupportedPlatform[];
    /**
     * The set of requirements for the tab.
     */
    requirementSet?: ElementRequirementSet;
}
export type StaticTabContext = "personalTab" | "channelTab" | "privateChatTab" | "meetingChatTab" | "meetingDetailsTab" | "meetingSidePanel" | "meetingStage" | "teamLevelApp";
export type StaticTabScope = "team" | "personal" | "groupChat";
/**
 * Subscription offer associated with this app.
 */
export interface SubscriptionOffer {
    /**
     * A unique identifier for the Commercial Marketplace Software as a Service Offer.
     */
    offerId: string;
}
export type SupportedChannelType = "sharedChannels" | "privateChannels";
/**
 * A property in the app manifest that declares support for all channel features,
 * categorized by tiers.
 */
export type SupportsChannelFeatures = "tier1" | "tier2";
/**
 * Specify your AAD App ID and Graph information to help users seamlessly sign into your AAD
 * app.
 */
export interface WebApplicationInfo {
    /**
     * AAD application id of the app. This id must be a GUID.
     */
    id: string;
    /**
     * Resource url of app for acquiring auth token for SSO.
     */
    resource?: string;
    /**
     * By including this property, an NAA token based on its contents will be prefetched when
     * the tab is loaded.
     */
    nestedAppAuthInfo?: NestedAppAuthInfo[];
}
export interface NestedAppAuthInfo {
    /**
     * Represents the nested app's valid redirect URI (always a base origin).
     */
    redirectUri: string;
    /**
     * Represents the stringified list of scopes the access token requested requires. Order must
     * match that of the proceeding NAA request in the app.
     */
    scopes: string[];
    /**
     * An optional JSON formatted object of client capabilities that represents if the resource
     * server is CAE capable. Do not use an empty string for this value. If unsupported, keep
     * the field undefined. If supported, use the following string exactly:
     * '{"access_token":{"xms_cc":{"values":["CP1"]}}}'. More info on client capabilities here:
     * https://learn.microsoft.com/en-us/entra/identity-platform/claims-challenge?tabs=dotnet#how-to-communicate-client-capabilities-to-microsoft-entra-id
     */
    claims?: string;
}
export declare class Convert {
    static toTeamsManifestVDevPreview(json: string): TeamsManifestVDevPreview;
    static teamsManifestVDevPreviewToJson(value: TeamsManifestVDevPreview): string;
}