{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "intents.json",
  "$defs": {
    "Identity": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "Opaque correlation value supplied by the producer. Preserve the value unchanged when forwarding or responding to the same invocation.",
          "title": "Unique identifier string for the intent invocation."
        }
      },
      "required": [
        "id"
      ],
      "description": "The identity is carried by intent envelopes that inherit from BasisIntent. Producers may use it to correlate an intent with its request or response; it does not identify the user, extension, or target entity.",
      "title": "Unique identity metadata for an intent invocation."
    },
    "Context": {
      "type": "object",
      "properties": {
        "imageIds": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "title": "Optional collection of image identifiers."
        }
      },
      "description": "Context communicates which entities are currently selected or otherwise relevant to an operation. It is supplementary to the payload and must not be treated as a substitute for an explicit target required by that payload.",
      "title": "Contextual entity identifiers associated with an intent execution."
    },
    "BasisIntent": {
      "type": "object",
      "properties": {
        "identity": {
          "$ref": "#/$defs/Identity",
          "description": "Correlation metadata for the invocation, should be kept intact during its whole lifecycle.",
          "title": "Optional unique identity metadata for the intent invocation."
        }
      },
      "description": "Intent payload models inherit this envelope when they need request correlation. The identity is optional so intents can also be dispatched without a correlation token.",
      "title": "Base intent model providing optional identity tracking."
    },
    "WithContextIntent": {
      "type": "object",
      "properties": {
        "context": {
          "$ref": "#/$defs/Context",
          "title": "Optional execution context containing target entity identifiers such as image identifiers."
        }
      },
      "allOf": [
        {
          "$ref": "#/$defs/BasisIntent"
        }
      ],
      "description": "It offers additional information about the context of execution the intent.",
      "title": "Base intent model extending BasisIntent with execution context references."
    },
    "WithTitle": {
      "type": "object",
      "properties": {
        "title": {
          "type": "string",
          "description": "Short heading intended for a title position in the associated UI. Keep this concise; place explanatory prose in description, subtitle, or details fields.",
          "title": "Optional headline or primary title text."
        }
      },
      "description": "Reusable heading metadata for dialog, notification, and view content. The title is optional in this base so that a consumer can render content that has a description or body without a heading.",
      "title": "Base content structure providing an optional title."
    },
    "WithSubtitle": {
      "type": "object",
      "properties": {
        "subtitle": {
          "type": "string",
          "description": "Short supporting message displayed below a title or as the main text of a compact notification. Use details or body fields for longer content.",
          "title": "Descriptive subtitle or message text."
        }
      },
      "required": [
        "subtitle"
      ],
      "description": "Reusable secondary text content. This model makes the subtitle required because its consumers use it as the primary short message when no separate body field is available.",
      "title": "Base content structure providing a subtitle."
    },
    "TitleSubtitle": {
      "type": "object",
      "properties": {
        "subtitle": {
          "type": "string",
          "description": "Short supporting message displayed below a title or as the main text of a compact notification. Use details or body fields for longer content.",
          "title": "Descriptive subtitle or message text."
        }
      },
      "required": [
        "subtitle"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithTitle"
        }
      ],
      "description": "Composition of the reusable title and subtitle fields for compact content that needs a heading and one supporting line.",
      "title": "Base content structure providing a title and subtitle."
    },
    "WithDescription": {
      "type": "object",
      "properties": {
        "description": {
          "type": "string",
          "description": "Explanatory text associated with the content. Use this for a short overview; additional or more detailed text can be supplied through a details field.",
          "title": "Descriptive subtitle or explanatory message text."
        }
      },
      "required": [
        "description"
      ],
      "description": "Reusable explanatory text for content that needs a description independent of its heading. The value is plain text and is not interpreted as markup.",
      "title": "Base content structure providing a description."
    },
    "WithDetails": {
      "type": "object",
      "properties": {
        "details": {
          "type": "string",
          "description": "Optional longer-form supporting content. Consumers may present it as secondary or expandable text; it remains plain text rather than a markup document.",
          "title": "Optional supplementary details or extended body text."
        }
      },
      "description": "Reusable extended body text, intended for information that is useful but should not be part of the primary heading or message.",
      "title": "Base content structure providing optional details."
    },
    "DescriptionDetails": {
      "type": "object",
      "properties": {
        "details": {
          "type": "string",
          "description": "Optional longer-form supporting content. Consumers may present it as secondary or expandable text; it remains plain text rather than a markup document.",
          "title": "Optional supplementary details or extended body text."
        }
      },
      "allOf": [
        {
          "$ref": "#/$defs/WithDescription"
        }
      ],
      "description": "Composition for explanatory content with a required overview and optional supplementary body text.",
      "title": "Base content structure providing a description and optional details."
    },
    "TitleDescriptionDetails": {
      "type": "object",
      "properties": {
        "title": {
          "type": "string",
          "title": "Primary title text displayed in the header."
        }
      },
      "required": [
        "title"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/DescriptionDetails"
        }
      ],
      "description": "Combines required descriptive content with an additional required title, suitable for cards where a heading and explanatory body are both needed.",
      "title": "Base content structure providing a title, description, and optional details."
    },
    "ResourceUrl": {
      "type": "object",
      "properties": {
        "url": {
          "type": "string",
          "description": "Location from which the front-end can retrieve the resource.",
          "title": "Resource destination URL."
        }
      },
      "required": [
        "url"
      ],
      "description": "Use a URL reference when the resource is available to the consumer through a location rather than inline bytes. The value is interpreted according to the resource consumer and may refer to remote or local content.",
      "title": "Resource reference pointing to an external or local URL."
    },
    "ResourceContent": {
      "type": "object",
      "properties": {
        "content": {
          "type": "string",
          "contentEncoding": "base64",
          "description": "Complete binary representation of the resource. The consumer is responsible for interpreting the bytes in the context in which the resource is used.",
          "title": "Raw binary byte content of the resource."
        }
      },
      "required": [
        "content"
      ],
      "description": "Use this representation to transfer a resource as bytes in the intent payload instead of requiring the consumer to resolve a separate URL.",
      "title": "Resource payload containing raw binary data."
    },
    "TitleDescriptionDetailsIcon": {
      "type": "object",
      "properties": {
        "icon": {
          "$ref": "#/$defs/Resource",
          "description": "Decorative or identifying image for the content header. Choose a URL for separately hosted assets or inline bytes when the asset must travel with the payload.",
          "title": "Optional visual icon resource — supplied as a URL or binary bytes."
        }
      },
      "allOf": [
        {
          "$ref": "#/$defs/TitleDescriptionDetails"
        }
      ],
      "description": "Combines a title and explanatory text with an optional icon for headers and notification cards. The icon can be supplied by URL or as bytes through Resource.",
      "title": "Base content structure extending TitleDescriptionDetails with an optional icon resource."
    },
    "Resource": {
      "anyOf": [
        {
          "$ref": "#/$defs/ResourceUrl",
          "title": "Resource located by URL."
        },
        {
          "$ref": "#/$defs/ResourceContent",
          "title": "Resource provided as raw binary bytes."
        }
      ],
      "description": "Exactly one resource representation is selected by the union variant: a resolvable location or inline binary data. Prefer URL references for reusable hosted assets and byte content when the payload must be self-contained.",
      "title": "Resource descriptor providing content either via URL or raw binary bytes."
    },
    "TitleSubtitleDescriptionDetailsIcon": {
      "type": "object",
      "properties": {
        "title": {
          "type": "string",
          "description": "Required concise heading for the content. It is distinct from the supporting subtitle and longer description/details fields.",
          "title": "Primary title text."
        },
        "details": {
          "type": "string",
          "description": "Optional longer-form supporting content. Consumers may present it as secondary or expandable text; it remains plain text rather than a markup document.",
          "title": "Optional supplementary details or extended body text."
        },
        "description": {
          "type": "string",
          "description": "Explanatory text associated with the content. Use this for a short overview; additional or more detailed text can be supplied through a details field.",
          "title": "Descriptive subtitle or explanatory message text."
        },
        "icon": {
          "$ref": "#/$defs/Resource",
          "description": "Optional image accompanying the content heading. Its resource can be inline or externally located, as described by Resource.",
          "title": "Optional visual icon resource — supplied as a URL or binary bytes."
        }
      },
      "required": [
        "title",
        "description"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/TitleSubtitle"
        }
      ],
      "description": "Combines the common heading and body fields for richer views. The title is required here; subtitle, description, and details are supplied by the composed content structures, while the icon remains optional.",
      "title": "Base content structure extending title, subtitle, description, and details content with an optional icon."
    },
    "DialogContent": {
      "type": "object",
      "properties": {},
      "allOf": [
        {
          "$ref": "#/$defs/TitleDescriptionDetails"
        }
      ],
      "description": "Convenience model for dialog text that requires a title and description with optional details, without an icon or size preference.",
      "title": "Textual content configuration for modal dialogs and notification cards."
    },
    "DialogIconContent": {
      "type": "object",
      "properties": {},
      "allOf": [
        {
          "$ref": "#/$defs/TitleDescriptionDetailsIcon"
        }
      ],
      "description": "Adds the optional resource icon to standard title and description content for dialogs.",
      "title": "Dialog content structure extending TitleDescriptionDetailsIcon with an optional icon resource."
    },
    "DialogIconSizeContent": {
      "type": "object",
      "properties": {
        "size": {
          "anyOf": [
            {
              "type": "string",
              "const": "auto"
            },
            {
              "type": "string",
              "const": "xs"
            },
            {
              "type": "string",
              "const": "s"
            },
            {
              "type": "string",
              "const": "m"
            },
            {
              "type": "string",
              "const": "l"
            },
            {
              "type": "string",
              "const": "xl"
            }
          ],
          "description": "Preferred modal size. Use auto when content should determine a suitable width; named sizes express a relative front-end-defined width rather than a pixel measurement.",
          "title": "Modal dialog window size variant."
        }
      },
      "allOf": [
        {
          "$ref": "#/$defs/DialogIconContent"
        }
      ],
      "description": "Controls the preferred width class of a modal dialog. The front-end may choose an appropriate actual width for its viewport when the preference is automatic or a fixed size cannot fit.",
      "title": "Dialog content structure extending DialogIconContent with a modal window size preference."
    },
    "FormContent": {
      "type": "object",
      "properties": {
        "parameters": {
          "$ref": "#/$defs/RecordUnknown",
          "description": "JSON Schema object describing the fields to render, including their types, titles, defaults, and validation constraints. Define an object schema with named properties so collected values can be returned as a keyed object.",
          "title": "JSON Schema specification describing form parameters, input types, default values, and validation rules."
        },
        "dialogContent": {
          "$ref": "#/$defs/DialogIconSizeContent",
          "description": "Optional title, descriptive content, icon, and preferred size for the form dialog. Leave this out when the form can use the front-end's default dialog presentation.",
          "title": "Optional presentation settings for the modal dialog housing the form."
        }
      },
      "required": [
        "parameters"
      ],
      "description": "The parameters value is a JSON Schema object used by the front-end to construct inputs and validate submitted values. Dialog content controls the surrounding modal presentation; it does not change the parameter schema.",
      "title": "Form configuration containing JSON Schema fields and optional dialog presentation settings."
    },
    "RecordUnknown": {
      "type": "object",
      "properties": {},
      "unevaluatedProperties": {}
    },
    "FormIntent": {
      "type": "object",
      "properties": {
        "form": {
          "$ref": "#/$defs/FormContent",
          "description": "Schema and optional modal presentation configuration for the requested form. The schema defines the form's inputs and validation rules.",
          "title": "Form configuration containing the JSON Schema parameters definition and dialog presentation settings."
        }
      },
      "required": [
        "form"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "The front-end renders the form associated to the schema, collects values, and returns them through the intent interaction flow. Use this for capturing structured input rather than embedding a hand-built form in a custom UI frame.",
      "title": "An intent that displays a JSON Schema-based form in a modal dialog to collect user input."
    },
    "UISidebarIntegration": {
      "type": "object",
      "properties": {
        "anchor": {
          "type": "string",
          "const": "sidebar",
          "description": "Literal integration discriminator for the sidebar variant. Keep it set to sidebar so consumers can distinguish this payload from other integration modes.",
          "title": "Layout anchor discriminator specifying sidebar placement."
        },
        "isExternal": {
          "type": "boolean",
          "description": "When true, asks the front-end to open the sidebar-backed view in a separate window. When false, the view is embedded in the sidebar; this flag does not change the integration anchor.",
          "title": "Whether the sidebar view should open in an external window rather than docked directly in the sidebar."
        }
      },
      "required": [
        "anchor",
        "isExternal"
      ],
      "description": "Selects the front-end's sidebar host as the integration point. The external flag allows the view to be presented in an independent window instead of occupying the docked sidebar surface.",
      "title": "UI integration configuration for mounting an extension view inside the collateral sidebar."
    },
    "UIWindowIntegration": {
      "type": "object",
      "properties": {
        "anchor": {
          "type": "string",
          "const": "window",
          "description": "Literal integration discriminator for the independent-window variant.",
          "title": "Layout anchor discriminator specifying window placement."
        }
      },
      "required": [
        "anchor"
      ],
      "description": "Selects a standalone host window without additional window-specific options in this contract.",
      "title": "UI integration configuration for rendering an extension view inside an independent window."
    },
    "UIModalIntegration": {
      "type": "object",
      "properties": {
        "anchor": {
          "type": "string",
          "const": "modal",
          "description": "Literal integration discriminator for the modal variant.",
          "title": "Layout anchor discriminator specifying modal placement."
        }
      },
      "required": [
        "anchor"
      ],
      "description": "Selects a front-end-managed modal as the host surface for the embedded extension view.",
      "title": "UI integration configuration for rendering an extension view inside a modal dialog."
    },
    "UITabIntegration": {
      "type": "object",
      "properties": {
        "anchor": {
          "type": "string",
          "const": "tab",
          "description": "Literal integration discriminator for the tab variant.",
          "title": "Layout anchor discriminator specifying tab placement."
        }
      },
      "required": [
        "anchor"
      ],
      "description": "Selects a dedicated front-end tab as the host surface for the embedded extension view.",
      "title": "UI integration configuration for rendering an extension view inside a tab."
    },
    "UrlContent": {
      "type": "object",
      "properties": {
        "url": {
          "type": "string",
          "description": "Address of the web document to load. The frame host must be able to reach the location; use a secure URL for remote content.",
          "title": "Target web URL to load inside the embedded frame."
        }
      },
      "required": [
        "url"
      ],
      "description": "URL-backed frame content is loaded by the front-end. The target must be reachable from that front-end's environment and should use an appropriate secure scheme.",
      "title": "Embedded frame content specified by a web URL."
    },
    "HtmlContent": {
      "type": "object",
      "properties": {
        "html": {
          "type": "string",
          "description": "HTML source rendered as the frame document. The TypeSpec contract treats it as an opaque string and does not validate markup or grant access to the host application's privileges.",
          "title": "Raw HTML markup string to render directly inside the embedded frame."
        }
      },
      "required": [
        "html"
      ],
      "description": "Inline document content supplied as a string. It is rendered by the host frame rather than fetched as a separate page; callers should not assume access to the host application's privileges.",
      "title": "Embedded frame content specified by raw inline HTML markup."
    },
    "Ui": {
      "type": "object",
      "properties": {
        "id": {
          "type": "string",
          "description": "Identifier for this view instance. Supply a stable identifier when the front-end should recognize the same registered view across invocations; otherwise use an identifier appropriate to the transient view lifecycle.",
          "title": "Unique identifier for the UI instance or transient panel."
        },
        "integration": {
          "$ref": "#/$defs/UIIntegration",
          "description": "Discriminated integration configuration. The anchor selects a supported host surface, while fields on that specific variant refine its presentation.",
          "title": "Placement strategy defining where and how the UI is mounted."
        },
        "frameContent": {
          "$ref": "#/$defs/FrameContent",
          "description": "Content source for the embedded frame. Supply one supported variant; use a URL for hosted application content or inline HTML for a self-contained document.",
          "title": "Web content to render inside the frame — either a URL or raw HTML."
        },
        "dialogContent": {
          "$ref": "#/$defs/DialogIconContent",
          "description": "Optional display metadata associated with the embedded view. It does not control the integration anchor or the content rendered within the frame.",
          "title": "Optional header title, description, and icon metadata for the view."
        }
      },
      "required": [
        "id",
        "integration",
        "frameContent"
      ],
      "description": "The front-end uses id to identify the view, integration to choose its host surface, and frameContent to load its contents. dialogContent supplies optional header metadata where the selected integration supports it.",
      "title": "Complete specification for embedding a custom extension user interface within the front-end."
    },
    "UIIntegration": {
      "anyOf": [
        {
          "$ref": "#/$defs/UISidebarIntegration",
          "title": "Collateral sidebar integration placement."
        },
        {
          "$ref": "#/$defs/UIWindowIntegration",
          "title": "Independent window integration placement."
        },
        {
          "$ref": "#/$defs/UIModalIntegration",
          "title": "Modal dialog integration placement."
        },
        {
          "$ref": "#/$defs/UITabIntegration",
          "title": "Tab integration placement."
        }
      ],
      "description": "Discriminated by each integration model's anchor field. Use the matching variant model so the anchor and any surface-specific settings remain consistent.",
      "title": "Union of supported UI integration placement strategies."
    },
    "FrameContent": {
      "anyOf": [
        {
          "$ref": "#/$defs/UrlContent",
          "title": "Frame content loaded from a URL."
        },
        {
          "$ref": "#/$defs/HtmlContent",
          "title": "Frame content provided as inline HTML markup."
        }
      ],
      "description": "Selects exactly one source for frame contents. The URL and inline HTML variants are alternative transport forms, not fields to combine in one value.",
      "title": "Union of supported embedded frame content formats — URL or inline HTML."
    },
    "UiIntent": {
      "type": "object",
      "properties": {
        "ui": {
          "$ref": "#/$defs/Ui",
          "description": "Required view descriptor containing the host integration, content source, and optional display metadata.",
          "title": "UI view configuration specifying placement anchor, content, and header metadata."
        }
      },
      "required": [
        "ui"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "Requests that the front-end mount the content in the selected integration surface, supplying the frame source and optional header metadata.",
      "title": "An intent that opens a dedicated UI frame — modal, sidebar, window or tab — rendering a URL or raw inline HTML."
    },
    "OpenBrowser": {
      "type": "object",
      "properties": {
        "url": {
          "type": "string",
          "format": "url",
          "description": "External destination passed to the platform's default browser.",
          "title": "Destination web URL to open externally in the default browser."
        }
      },
      "required": [
        "url"
      ],
      "description": "This payload targets external browser navigation rather than an embedded UI frame. The operating system or front-end handles the actual hand-off to the default browser.",
      "title": "Parameters for opening an external web URL in the user's default browser."
    },
    "OpenBrowserIntent": {
      "type": "object",
      "properties": {
        "openBrowser": {
          "$ref": "#/$defs/OpenBrowser",
          "description": "Required URL payload passed to the operating system or front-end for external browser navigation.",
          "title": "External browser navigation payload containing the target URL."
        }
      },
      "required": [
        "openBrowser"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/BasisIntent"
        }
      ],
      "title": "An intent that prompts the user for confirmation and opens an external URL in the default web browser."
    },
    "Frame": {
      "type": "object",
      "properties": {
        "content": {
          "$ref": "#/$defs/FrameContent",
          "description": "Source for the embedded content. The selected FrameContent variant determines whether the front-end loads a URL or renders supplied markup.",
          "title": "Embedded web content to render inside the dialog frame."
        },
        "height": {
          "type": "integer",
          "minimum": 0,
          "maximum": 100,
          "description": "Relative height request, bounded from 0 through 100. A value of 100 requests the full available dialog height; the final rendered dimensions remain controlled by the front-end.",
          "title": "Frame height expressed as a percentage of available dialog height (0 to 100)."
        }
      },
      "required": [
        "content",
        "height"
      ],
      "description": "The frame embeds URL- or HTML-based content in a dialog body. Its height is expressed as a percentage of the available dialog height so that the front-end can adapt the frame to the dialog's rendered dimensions.",
      "title": "Embedded frame configuration rendered within a dialog modal."
    },
    "DialogButtons": {
      "type": "object",
      "properties": {
        "yes": {
          "type": "string",
          "description": "Text shown for the affirmative action. Keep it specific to the requested decision when possible.",
          "title": "Label text for the primary affirmative / confirmation button."
        },
        "no": {
          "type": "string",
          "description": "Text shown for the secondary choice, commonly a cancellation label. Omission leaves that choice to the front-end's default dialog behavior.",
          "title": "Optional label text for the secondary negative / cancellation button."
        }
      },
      "required": [
        "yes"
      ],
      "description": "Defines user-visible text for the dialog's affirmative choice and optional secondary choice. These labels are presentation strings, not command identifiers.",
      "title": "Button label configuration for interactive dialog actions."
    },
    "Dialog": {
      "type": "object",
      "properties": {
        "type": {
          "$ref": "#/$defs/DialogType",
          "description": "Selects the dialog's interaction and visual treatment. Use question when the caller needs a yes/no choice, and error or info for non-question messages.",
          "title": "Semantic dialog type — error, info, or question."
        },
        "frame": {
          "$ref": "#/$defs/Frame",
          "description": "Optional embedded content displayed within the dialog. Omit it for text-only dialogs; when present, content should be suitable for the dialog's available space.",
          "title": "Optional embedded HTML or URL frame rendered inside the dialog body."
        },
        "buttons": {
          "$ref": "#/$defs/DialogButtons",
          "description": "Labels for the affirmative action and optional secondary cancellation action. The front-end determines the button behavior and returns the user's choice to the intent caller.",
          "title": "Button label definitions for user response choices."
        }
      },
      "required": [
        "type",
        "buttons"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/DialogIconSizeContent"
        }
      ],
      "description": "Defines the dialog's semantic type and user-facing content, with optional embedded content and button labels. Use question for a decision that requires an explicit response; other types communicate status or errors.",
      "title": "Configuration for interactive modal dialogs displaying notices, confirmation questions, or embedded frames."
    },
    "DialogType": {
      "type": "string",
      "enum": [
        "error",
        "info",
        "question"
      ],
      "title": "Semantic classification and visual styling category of a modal dialog."
    },
    "DialogIntent": {
      "type": "object",
      "properties": {
        "dialog": {
          "$ref": "#/$defs/Dialog",
          "description": "Required modal content and interaction configuration. Its type, buttons, and optional frame determine what the user sees and which response can be returned.",
          "title": "Modal dialog configuration including type, title, buttons, and optional frame content."
        }
      },
      "required": [
        "dialog"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "Requests a front-end-managed modal using the supplied dialog configuration. The front-end presents the available controls and resolves the interaction with the user's response.",
      "title": "An intent that displays an interactive modal dialog and returns the user's response."
    },
    "Image": {
      "type": "object",
      "properties": {
        "imageId": {
          "type": "string",
          "description": "Identifier used by the front-end to resolve the image from its repositories. This is a image identifier, not an image URL or binary payload.",
          "title": "Unique identifier of the image in repositories."
        },
        "details": {
          "$ref": "#/$defs/TitleDescriptionDetails",
          "description": "Optional display metadata associated with this image entry. The front-end can use it as a per-image caption or descriptive context without changing the referenced image.",
          "title": "Optional title, description, or detail text for the individual image."
        }
      },
      "required": [
        "imageId"
      ],
      "description": "An image entry references an existing image by identifier and may override or augment its displayed textual details.",
      "title": "Individual image descriptor for gallery presentation."
    },
    "ImagesContent": {
      "type": "object",
      "properties": {},
      "allOf": [
        {
          "$ref": "#/$defs/TitleSubtitleDescriptionDetailsIcon"
        }
      ],
      "description": "Header metadata specialized for the image gallery tab. It reuses the common content fields so gallery presentation follows the same title, text, and icon conventions as other views.",
      "title": "Content configuration for image gallery presentation containing title, subtitle, description, details, and an optional icon."
    },
    "Images": {
      "type": "object",
      "properties": {
        "images": {
          "type": "array",
          "items": {
            "$ref": "#/$defs/Image"
          },
          "description": "Ordered gallery entries. The sequence supplied here is the order in which images are presented by the front-end.",
          "title": "List of image items to display in the gallery tab."
        },
        "content": {
          "$ref": "#/$defs/ImagesContent",
          "description": "Title, subtitle, description, details, and optional icon for the gallery view header.",
          "title": "Header content configuration for the image gallery tab."
        }
      },
      "required": [
        "images",
        "content"
      ],
      "description": "Pairs the gallery's image entries with the header content shown above them. Each entry points to an existing image; this model does not carry image bytes.",
      "title": "Collection of image items displayed inside a dedicated gallery tab."
    },
    "ImagesIntent": {
      "type": "object",
      "properties": {
        "images": {
          "$ref": "#/$defs/Images",
          "description": "Required gallery payload containing both the image references and the content used to describe the tab.",
          "title": "Image collection items and header metadata for the tab view."
        }
      },
      "required": [
        "images"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "Requests a dedicated desk tab for the supplied ordered image collection and header metadata.",
      "title": "An intent that opens a tab displaying an image gallery."
    },
    "Show": {
      "type": "object",
      "properties": {
        "type": {
          "$ref": "#/$defs/ShowType",
          "description": "Selects which front-end surface or entity resolver handles the navigation request. The id property must identify an entity compatible with this category.",
          "title": "Target view or entity category discriminator."
        },
        "id": {
          "type": "string",
          "description": "Identifier consumed by the selected destination resolver, for example an image ID for image, repository ID for repository, or extension ID for extensionSettings.",
          "title": "Unique identifier of the target entity — such as an image ID, repository ID, sidebar UUID, or extension ID."
        }
      },
      "required": [
        "type",
        "id"
      ],
      "description": "Combines a front-end-recognized view category with the identifier needed to resolve the destination. Valid identifier formats depend on the selected view type.",
      "title": "Navigation payload targeting a specific view, panel, or entity."
    },
    "ShowType": {
      "type": "string",
      "enum": [
        "sidebar",
        "extensionSettings",
        "image",
        "repository"
      ],
      "title": "Target view or entity type to display in the front-end."
    },
    "ShowIntent": {
      "type": "object",
      "properties": {
        "show": {
          "$ref": "#/$defs/Show",
          "description": "Destination descriptor used by the front-end to select the view and resolve its target.",
          "title": "Target entity and view type specification to display."
        }
      },
      "required": [
        "show"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/BasisIntent"
        }
      ],
      "description": "It requests navigation in the front-end using a type-and-identifier pair.",
      "title": "An intent that navigates the front-end to a specific view, opening an image detail modal, a registered sidebar panel, an extension settings modal, or a repository view."
    },
    "Toast": {
      "type": "object",
      "properties": {
        "type": {
          "$ref": "#/$defs/ToastType",
          "description": "Controls the font-end-side visual treatment and communicates the message category; it does not alter the notification text.",
          "title": "Visual style and severity variant of the toast."
        }
      },
      "required": [
        "type"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/TitleSubtitle"
        }
      ],
      "description": "Toast content is intended for transient status feedback rather than a durable notification or an interaction requiring a decision.",
      "title": "Configuration payload for brief, non-intrusive toast notifications."
    },
    "ToastType": {
      "type": "string",
      "enum": [
        "info",
        "cancel",
        "error"
      ],
      "title": "Visual style and severity variant for toast notifications."
    },
    "ToastIntent": {
      "type": "object",
      "properties": {
        "toast": {
          "$ref": "#/$defs/Toast",
          "description": "Required toast content and severity configuration.",
          "title": "Toast notification configuration specifying type, title, and subtitle text."
        }
      },
      "required": [
        "toast"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "It dispatches a transient status feedback to the front-end.",
      "title": "An intent that displays a brief, non-intrusive toast notification in the front-end."
    },
    "Notification": {
      "type": "object",
      "properties": {
        "title": {
          "type": "string",
          "description": "Short heading shown as the notification's primary label.",
          "title": "Primary notification title heading."
        },
        "body": {
          "type": "string",
          "description": "Main explanatory text shown with the notification title and subtitle. Keep the body understandable when the user sees it outside the surrounding application context.",
          "title": "Detailed notification message body."
        },
        "silent": {
          "type": "boolean",
          "description": "Set true when delivery should not produce an audible alert. This preference does not suppress the visual notification.",
          "title": "Whether audio alert chimes and sounds should be suppressed."
        },
        "icon": {
          "type": "string",
          "contentEncoding": "base64",
          "description": "Image bytes supplied for the notification icon. The target notification surface may apply its own size and format constraints.",
          "title": "Optional raw binary image icon displayed with the notification."
        },
        "isNative": {
          "type": "boolean",
          "description": "Selects native desktop notification delivery when true. When false, the front-end notification center is the target; actual OS behavior is subject to platform support.",
          "title": "Whether the notification is dispatched through the operating system native desktop notification manager."
        }
      },
      "required": [
        "title",
        "body",
        "silent",
        "isNative"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/TitleSubtitle"
        }
      ],
      "description": "Provides content and delivery preferences for a notification. The consumer can route it to the in-app notification center, the operating system notification manager, or both according to its supported behavior.",
      "title": "Notification payload for notification center cards or native desktop notifications."
    },
    "NotificationIntent": {
      "type": "object",
      "properties": {
        "notification": {
          "$ref": "#/$defs/Notification",
          "description": "Required notification content and delivery options.",
          "title": "Notification details including title, subtitle, body, icon, and delivery mode."
        }
      },
      "required": [
        "notification"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "It sends a notification content with delivery preferences to the front-end.",
      "title": "An intent that dispatches a notification to the front-end notification center or operating system native desktop notification manager."
    },
    "ProcessCommand": {
      "type": "object",
      "properties": {
        "extensionId": {
          "type": "string",
          "description": "Identifier of the installed extension that registers the command. It scopes commandId to the correct extension.",
          "title": "Unique identifier of the extension owning the target command."
        },
        "commandId": {
          "type": "string",
          "description": "Identifier of the command registered by the owning extension. The extension's command handler determines the accepted input and execution behavior.",
          "title": "Unique identifier of the command to execute on the extension."
        }
      },
      "required": [
        "extensionId",
        "commandId"
      ],
      "description": "A command is resolved within its owning extension, so both identifiers are required to avoid ambiguity across installed extensions.",
      "title": "Specification identifying an extension command for programmatic invocation."
    },
    "ProcessCommandIntent": {
      "type": "object",
      "properties": {
        "processCommand": {
          "$ref": "#/$defs/ProcessCommand",
          "description": "Identifies the extension and command that the front-end should invoke.",
          "title": "Extension and command identification payload."
        }
      },
      "required": [
        "processCommand"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "It asks the front-end to execute an command, submitted its form when it requires inputs.",
      "title": "An intent that triggers execution of an extension command within the current context."
    },
    "Action": {
      "type": "object",
      "properties": {
        "intent": {
          "anyOf": [
            {
              "$ref": "#/$defs/ShowIntent"
            },
            {
              "$ref": "#/$defs/UiIntent"
            },
            {
              "$ref": "#/$defs/OpenBrowserIntent"
            },
            {
              "$ref": "#/$defs/ProcessCommandIntent"
            }
          ],
          "description": "Intent dispatched as the action's effect. Only the supported intent variants are accepted; the action itself does not execute or validate the nested operation.",
          "title": "Underlying intent executed when the user confirms the action button."
        },
        "dialogContent": {
          "$ref": "#/$defs/DialogIconSizeContent",
          "description": "User-facing card content displayed with the action button.",
          "title": "Header title, description, details, icon, and sizing configuration for the action card."
        },
        "label": {
          "type": "string",
          "description": "Optional concise text for the button that activates the nested intent.",
          "title": "Optional label text for the action confirmation button."
        }
      },
      "required": [
        "intent",
        "dialogContent"
      ],
      "description": "Combines user-facing card content and an executable intent. The notification center can present the card and dispatch the nested intent only after the user activates its action.",
      "title": "Interactive action card configuration bundling an executable intent triggered by a notification button."
    },
    "ActionIntent": {
      "type": "object",
      "properties": {
        "action": {
          "$ref": "#/$defs/Action",
          "description": "Required card configuration, including the intent to dispatch after user activation.",
          "title": "Action card configuration including header content, action button label, and underlying intent."
        }
      },
      "required": [
        "action"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "It publishes a user-facing action card containing a nested intent. The nested operation is dispatched in response to the user's activation rather than immediately when this intent is handled.",
      "title": "An intent that posts an entry to the front-end notification center, executing an action when the user clicks its action button."
    },
    "ServeBundle": {
      "type": "object",
      "properties": {
        "content": {
          "type": "string",
          "contentEncoding": "base64",
          "description": "ZIP-encoded bundle containing the entry HTML document and its static dependencies. The archive must be suitable for extraction and static hosting; this property is the archive bytes, not a URL to an existing bundle.",
          "title": "Binary ZIP archive payload containing static web application assets (HTML, CSS, JS)."
        },
        "settings": {
          "$ref": "#/$defs/RecordUnknown",
          "description": "JSON-compatible key/value settings made available to the hosted application when it is initialized.",
          "title": "Optional initial configuration parameters or settings forwarded to the served bundle."
        }
      },
      "required": [
        "content"
      ],
      "description": "The server accepts a ZIP archive of static assets and hosts it for use in an embedded frame. Configuration is passed to the served application separately from the archive contents.",
      "title": "Configuration for uploading and hosting a static web application bundle on the back-end."
    },
    "ServeBundleIntent": {
      "type": "object",
      "properties": {
        "serveBundle": {
          "$ref": "#/$defs/ServeBundle",
          "description": "Required data used by the server to host the static application bundle.",
          "title": "Bundle archive payload and optional configuration settings."
        }
      },
      "required": [
        "serveBundle"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/BasisIntent"
        }
      ],
      "description": "The back-end hosts the supplied static assets and returns a URL that can be used to open the application in a frame.",
      "title": "An intent for uploading and hosting a web application bundle or a plain HTML page on the back-end."
    },
    "ReadFile": {
      "type": "object",
      "properties": {
        "extensions": {
          "type": "array",
          "items": {
            "type": "string"
          },
          "description": "File extensions offered as selection filters. Supply extensions without a leading dot; omit this field to leave the available file types unrestricted by the request.",
          "title": "Optional list of allowed file extension filters (e.g. ['json', 'png'])."
        },
        "message": {
          "type": "string",
          "description": "User-facing prompt describing what file should be selected. It is informational and does not enforce the extension filters.",
          "title": "Informational dialog prompt message displayed to the user during file selection."
        }
      },
      "required": [
        "message"
      ],
      "description": "Specifies the filters and prompt used by the host's file picker. The selected file content is returned by the corresponding read-file operation.",
      "title": "Parameters for prompting the user to select an existing file through a native file picker dialog."
    },
    "ReadFileIntent": {
      "type": "object",
      "properties": {
        "readFile": {
          "$ref": "#/$defs/ReadFile",
          "description": "Required file picker request. The selected bytes are returned by the host operation.",
          "title": "File filter extensions and dialog prompt message configuration."
        }
      },
      "required": [
        "readFile"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "It requests a file picker with the supplied filters and prompt. The selected content is returned to the caller as binary data; the extension does not receive a filesystem path through this contract.",
      "title": "An intent for prompting the user to select an existing file through a native file picker dialog."
    },
    "WriteFile": {
      "type": "object",
      "properties": {
        "name": {
          "type": "string",
          "description": "Suggested base name shown in the save dialog. Keep the extension in its separate property to avoid a duplicated suffix.",
          "title": "Default suggested filename without extension."
        },
        "extension": {
          "type": "string",
          "description": "Suffix associated with the saved file. Supply the extension expected by the content format, without relying on the host to infer it from the bytes.",
          "title": "File extension to apply to the saved file."
        },
        "content": {
          "type": "string",
          "contentEncoding": "base64",
          "description": "Complete file payload written if the user confirms the save operation.",
          "title": "Binary byte content to write to disk upon user confirmation."
        },
        "message": {
          "type": "string",
          "description": "User-facing explanation of the file being saved. It supplements the suggested name and does not choose the destination path.",
          "title": "Informational dialog prompt message displayed to the user during file saving."
        }
      },
      "required": [
        "name",
        "extension",
        "content",
        "message"
      ],
      "description": "Specifies the suggested output name, extension, bytes, and prompt for a host-managed save dialog. The host controls the destination path and confirms the write with the user.",
      "title": "Parameters for prompting the user to save a file to disk through a native file save dialog."
    },
    "WriteFileIntent": {
      "type": "object",
      "properties": {
        "writeFile": {
          "$ref": "#/$defs/WriteFile",
          "description": "Required save request containing the suggested name, output extension, content, and user-facing prompt.",
          "title": "Target file name, extension, binary content, and dialog prompt message configuration."
        }
      },
      "required": [
        "writeFile"
      ],
      "allOf": [
        {
          "$ref": "#/$defs/WithContextIntent"
        }
      ],
      "description": "Requests a host-managed save dialog using the proposed filename, extension, and content. The user and host determine the destination; callers should handle cancellation according to the surrounding intent flow.",
      "title": "An intent that prompts the user to save some content to disk through a native file saver dialog."
    },
    "UiAnchor": {
      "type": "string",
      "enum": [
        "modal",
        "sidebar",
        "window",
        "imageDetail",
        "tab"
      ],
      "description": "The selected anchor is the discriminator for the supported integration surface. Its string value is part of the serialized intent contract and must match one of these declared choices.",
      "title": "Target layout anchor where an embedded extension user interface should be integrated."
    }
  }
}