@instructure/canvas-rce 5.15.4 → 5.15.6

package/es/rce/plugins/instructure_rce_external_tools/ExternalToolsEnv.d.ts

@@ -0,0 +1,30 @@
+import type { ExternalToolsEditor, RCEWrapperInterface, RCEWrapperProps } from '../../types';
+/**
+ * Type of the "editor buttons" that come from Canvas.
+ *
+ * They're actually the available LTI Tool configurations, so we give them a more reasonable name here.
+ */
+export type RceLtiToolInfo = NonNullable<NonNullable<RCEWrapperProps['ltiTools']>[number]>;
+export interface ExternalToolsEnv {
+    editor: ExternalToolsEditor | null;
+    rceWrapper: RCEWrapperInterface | null;
+    availableRceLtiTools: RceLtiToolInfo[];
+    contextAssetInfo: {
+        contextType: string;
+        contextId: string;
+    } | null;
+    resourceSelectionUrlOverride: string | null;
+    ltiIframeAllowPolicy: string;
+    isA2StudentView: boolean;
+    maxMruTools: number;
+    canvasOrigin: string;
+    containingCanvasLtiToolId: string | null;
+    editorSelection: string | null;
+    editorContent: string | null;
+    insertCode(code: string): any;
+    replaceCode(code: string): any;
+}
+/**
+ * Gets the environment information for the external tools dialog for a given tinyMCE editor.
+ */
+export declare function externalToolsEnvFor(editor: ExternalToolsEditor | null | undefined): ExternalToolsEnv;

package/es/rce/plugins/instructure_rce_external_tools/RceToolWrapper.d.ts

@@ -0,0 +1,77 @@
+import type { ExternalToolsEnv, RceLtiToolInfo } from './ExternalToolsEnv';
+export interface ExternalToolMenuItem {
+    type: 'menuitem';
+    text: string;
+    icon?: string;
+    onAction: () => void;
+}
+/**
+ * Helper class for the connection between an external tool registration and a particular TinyMCE instance.
+ */
+export declare class RceToolWrapper {
+    readonly env: ExternalToolsEnv;
+    private readonly toolInfo;
+    static forEditorEnv(env: ExternalToolsEnv, toolConfigs?: (import("prop-types").InferPropsInner<Pick<{
+        id: import("prop-types").Requireable<NonNullable<string | number | null | undefined>>;
+        favorite: import("prop-types").Requireable<boolean>;
+        on_by_default: import("prop-types").Requireable<boolean>;
+        name: import("prop-types").Requireable<string>;
+        description: import("prop-types").Requireable<string>;
+        icon_url: import("prop-types").Requireable<string>;
+        height: import("prop-types").Requireable<number>;
+        width: import("prop-types").Requireable<number>;
+        use_tray: import("prop-types").Requireable<boolean>;
+        canvas_icon_class: import("prop-types").Requireable<any>;
+    }, never>> & Partial<import("prop-types").InferPropsInner<Pick<{
+        id: import("prop-types").Requireable<NonNullable<string | number | null | undefined>>;
+        favorite: import("prop-types").Requireable<boolean>;
+        on_by_default: import("prop-types").Requireable<boolean>;
+        name: import("prop-types").Requireable<string>;
+        description: import("prop-types").Requireable<string>;
+        icon_url: import("prop-types").Requireable<string>;
+        height: import("prop-types").Requireable<number>;
+        width: import("prop-types").Requireable<number>;
+        use_tray: import("prop-types").Requireable<boolean>;
+        canvas_icon_class: import("prop-types").Requireable<any>;
+    }, "description" | "id" | "name" | "height" | "width" | "favorite" | "on_by_default" | "icon_url" | "use_tray" | "canvas_icon_class">>>)[], mruIds?: string[]): RceToolWrapper[];
+    readonly iconId: string | null | undefined;
+    isMruTool: boolean;
+    get editor(): import("../../types").ExternalToolsEditor | null;
+    constructor(env: ExternalToolsEnv, toolInfo: RceLtiToolInfo, mruToolIds: string[]);
+    get id(): string;
+    get title(): string;
+    get description(): string | null | undefined;
+    get favorite(): boolean;
+    get image(): string | null | undefined;
+    get width(): number | null | undefined;
+    get height(): number | null | undefined;
+    get use_tray(): boolean | null | undefined;
+    get on_by_default(): boolean | null | undefined;
+    asToolbarButton(): {
+        readonly type: "button";
+        readonly icon: string | undefined;
+        readonly tooltip: string;
+        readonly onAction: () => void;
+    };
+    asMenuItem(): {
+        readonly type: "menuitem";
+        readonly text: string;
+        readonly icon: string | undefined;
+        readonly onAction: () => void;
+    };
+    openDialog(): void;
+}
+export declare function parseIconValueFor(toolInfo: RceLtiToolInfo): {
+    iconUrl?: string;
+    canvasIconClass?: string;
+};
+/**
+ * Loads the list of most recently used external tool ids.
+ */
+export declare function loadMruToolIds(): string[];
+/**
+ * Loads the list of most recently used external tool ids.
+ */
+export declare function storeMruToolIds(toolIds: string[]): void;
+export declare function addMruToolId(toolId: string, env: ExternalToolsEnv): string[];
+export declare function buildToolMenuItems(availableTools: RceToolWrapper[], viewAllItem: ExternalToolMenuItem): ExternalToolMenuItem[];

package/es/rce/plugins/instructure_rce_external_tools/components/ExternalToolDialog/ExternalToolDialog.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import { ExternalToolsEnv } from '../../ExternalToolsEnv';
+import { RceToolWrapper } from '../../RceToolWrapper';
+export interface ExternalToolDialogProps {
+    env: ExternalToolsEnv;
+    iframeAllowances: string;
+    resourceSelectionUrlOverride?: string | null;
+}
+export default class ExternalToolDialog extends React.Component<ExternalToolDialogProps, ExternalToolDialogState> {
+    static defaultProps: Partial<ExternalToolDialogProps>;
+    state: ExternalToolDialogState;
+    formRef: React.RefObject<HTMLFormElement>;
+    beforeInfoAlertRef: React.RefObject<HTMLDivElement>;
+    afterInfoAlertRef: React.RefObject<HTMLDivElement>;
+    iframeRef: React.RefObject<HTMLIFrameElement>;
+    open(button: RceToolWrapper): void;
+    close(): void;
+    handleBeforeUnload: (ev: Event) => string;
+    private handleExternalContentReady;
+    get resourceSelectionOrigin(): string;
+    handlePostedMessage: (ev: Pick<MessageEvent, "origin" | "data">) => void;
+    handleClose: () => void;
+    handleOpen: () => void;
+    handleRemove: () => void;
+    handleInfoAlertFocus: (ev: {
+        target: Element;
+    }) => void;
+    handleInfoAlertBlur: () => void;
+    calcIFrameHeight: () => string;
+    render(): React.JSX.Element;
+}
+interface ExternalToolDialogState {
+    open: boolean;
+    button: RceToolWrapper | null;
+    infoAlert: Element | null;
+    form: ExternalToolDialogForm;
+    iframeLoaded: boolean;
+}
+export interface ExternalToolDialogForm {
+    url: string;
+    selection: string;
+    contents: string;
+    parent_frame_context: string | null;
+}
+export {};

package/es/rce/plugins/instructure_rce_external_tools/components/ExternalToolDialog/ExternalToolDialogModal.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ReactNodeLike } from 'prop-types';
+import { ModalProps } from '@instructure/ui-modal/types';
+export declare function ExternalToolDialogModal(props: Pick<ModalProps, 'label' | 'open' | 'onOpen' | 'onClose' | 'mountNode'> & {
+    onCloseButton: () => void;
+    name: string;
+    children: ReactNodeLike;
+}): React.JSX.Element;

package/es/rce/plugins/instructure_rce_external_tools/components/ExternalToolDialog/ExternalToolDialogTray.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+import type { TrayProps } from '@instructure/ui-tray';
+interface ExternalToolDialogTrayProps {
+    open: TrayProps['open'];
+    label: TrayProps['label'];
+    mountNode: TrayProps['mountNode'];
+    onOpen?: TrayProps['onOpen'];
+    onClose?: TrayProps['onClose'];
+    onCloseButton?: () => void;
+    name: string;
+    children: TrayProps['children'];
+}
+export declare function ExternalToolDialogTray(props: ExternalToolDialogTrayProps): React.JSX.Element;
+export {};

package/es/rce/plugins/instructure_rce_external_tools/components/ExternalToolSelectionDialog/ExternalToolSelectionDialog.d.ts

@@ -0,0 +1,18 @@
+import { RceToolWrapper } from '../../RceToolWrapper';
+/**
+ * Returns a filtered list of items based on the term.
+ *
+ * This was copied from legacy code, and feels like it should be replaced by a string matching library.
+ *
+ * @param searchString search term
+ * @param items objects to filter
+ * @return matching items if a non-blank search term is provided, otherwise a copy of the original list
+ */
+export declare function filterItemsByTitleSubstring<T extends {
+    title: string;
+}>(searchString: string | undefined | null, items: T[]): T[];
+export interface ExternalToolSelectionDialogProps {
+    ltiButtons: RceToolWrapper[];
+    onDismiss: () => void;
+}
+export declare function ExternalToolSelectionDialog(props: ExternalToolSelectionDialogProps): JSX.Element;

package/es/rce/plugins/instructure_rce_external_tools/components/ExternalToolSelectionDialog/ExternalToolSelectionItem.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+export interface LtiToolProps {
+    title: string;
+    image?: string | null;
+    onAction: () => void;
+    description?: string | null;
+}
+export default function ExternalToolSelectionItem(props: LtiToolProps): React.JSX.Element;
+export declare const styles: {
+    appTitle: object;
+    appButton: object;
+};

package/es/rce/plugins/instructure_rce_external_tools/components/util/ExpandoText.d.ts

@@ -0,0 +1,7 @@
+export default function ExpandoText(props: {
+    text: string;
+    title: string;
+}): JSX.Element;
+export declare const styles: {
+    descriptionText: object;
+};

package/es/rce/plugins/instructure_rce_external_tools/components/util/ToolLaunchIframe.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+/**
+ * Provide an iframe for launching an LTI tool directly from the frontend.
+ * Works just like all existing usages of the LTI <iframe> element, including
+ * extracting a ref of the <iframe> directly and setting things on it later.
+ */
+declare const ToolLaunchIframe: React.ForwardRefExoticComponent<React.IframeHTMLAttributes<HTMLIFrameElement> & {
+    children?: React.ReactNode | undefined;
+} & React.RefAttributes<HTMLIFrameElement>>;
+export default ToolLaunchIframe;

package/es/rce/plugins/instructure_rce_external_tools/constants.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Name of the parameter used to indicate to Canvas that it is being loaded in an iframe inside of an
+ * LTI tool. It should be set to the global id of the containing tool.
+ */
+export declare const parentFrameContextParam = "parent_frame_context";
+/**
+ * Fallback iframe allowances used when they aren't provided to the editor.
+ */
+export declare const fallbackIframeAllowances: string[];

package/es/rce/plugins/instructure_rce_external_tools/dialog-helper.d.ts

@@ -0,0 +1,3 @@
+import { RceToolWrapper } from './RceToolWrapper';
+export declare function ensureToolDialogContainerElem(): HTMLDivElement;
+export declare function openToolDialogFor(toolHelper: RceToolWrapper): void;

package/es/rce/plugins/instructure_rce_external_tools/helpers/tags.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Performs interpolation on the given text, replacing `{{name}}` with `value`.
+ *
+ * @param text The text to interpolate
+ * @param name The name of the tag to replace
+ * @param value The value to replace the tag with
+ */
+export declare function replaceOneTag<TInput extends string | null | undefined = string>(text: TInput, name: string | null | undefined, value: string | null | undefined): TInput;
+/**
+ * Performs interpolation on the given text, replacing one or more tags in the form `{{tag}}` with a value.
+ *
+ * Takes either a single tag name and value, or a record of tag name -> tag value
+ *
+ * @param text The text to interpolate
+ * @param mappingOrName The mapping record or tag name
+ * @param maybeValue The value to replace with, if a single tag name was provided
+ */
+export declare function replaceTags<TNull extends never | null | undefined = never>(text: string | TNull, mappingOrName: Record<string, string> | string, maybeValue?: string): string | TNull;

package/es/rce/plugins/instructure_rce_external_tools/jquery/jquery.dropdownList.d.ts

@@ -0,0 +1,27 @@
+/**
+ * TL;DR: Remove this file when possible.
+ *
+ * Please note that this file is considered very legacy.  All instances of it
+ * should be evaluated and replaced with the newer and far better looking
+ * KyleMenu.  The only other place that I've seen it in used is the file
+ * attendance.js which is on the chopping block at some point in the future.
+ * Once that file has been axed, then this file should be able to be removed.
+ */
+interface DropdownListOptions {
+    height: number;
+    width: 'auto' | number;
+}
+declare global {
+    interface Window {
+        jQuery?: JQuery;
+        $?: JQuery;
+    }
+    interface JQuery {
+        dropdownList: ((this: JQuery, options: 'hide' | 'remove' | (Partial<DropdownListOptions> & {
+            options?: Record<string, Function | undefined>;
+        })) => this) & {
+            defaults: DropdownListOptions;
+        };
+    }
+}
+export {};

package/es/rce/plugins/instructure_rce_external_tools/lti11-content-items/RceLti11ContentItem.d.ts

@@ -0,0 +1,72 @@
+import { DeepPartialNullable } from '../../../../util/DeepPartialNullable';
+import { ExternalToolsEnv } from '../ExternalToolsEnv';
+import { StudioContentItemCustomJson } from '../../shared/StudioLtiSupportUtils';
+export declare class RceLti11ContentItem {
+    readonly contentItem: RceLti11ContentItemJson;
+    readonly env: ExternalToolsEnv;
+    static fromJSON(contentItem: RceLti11ContentItemJson, env?: ExternalToolsEnv): RceLti11ContentItem;
+    constructor(contentItem: RceLti11ContentItemJson, env?: ExternalToolsEnv);
+    get text(): string | null | undefined;
+    get isLTI(): boolean;
+    get isOverriddenForThumbnail(): boolean | null | undefined;
+    get isImage(): boolean;
+    get linkClassName(): string;
+    get url(): string | undefined;
+    get linkTarget(): string | null;
+    get docTarget(): string | undefined;
+    get codePayload(): string;
+    private get containingCanvasLtiToolId();
+    private get currentTinyMceSelection();
+    private generateCodePayloadIframe;
+    private generateCodePayloadEmbed;
+    private generateCodePayloadText;
+    private generateCodePayloadLink;
+    private generateLinkHtml;
+}
+/**
+ * Declare the global tinyMCE information used to pass editor context around in Canvas.
+ *
+ * Eventually, this should be moved into packages/canvas-rce.
+ */
+declare global {
+    interface Window {
+        tinyMCE?: {
+            activeEditor?: {
+                selection: {
+                    getContent(): string;
+                };
+            };
+        } | null;
+    }
+}
+/**
+ * Interface for content items that come from external tool resource selection.
+ *
+ * Note that this interface may not be exhaustive, but provides types for the portion of ContentItem used by Canvas.
+ * Additionally, there are some extra properties present here used by canvas
+ *
+ * See https://www.imsglobal.org/spec/lti-dl/v2p0#content-item-types
+ * and https://www.imsglobal.org/lti/model/mediatype/application/vnd/ims/lti/v1/contentitems%2Bjson/index.html
+ * and https://www.imsglobal.org/lti/model/mediatype/application/vnd/ims/lti/v1/contentitems%2Bjson/context.json
+ */
+export type RceLti11ContentItemJson = DeepPartialNullable<{
+    '@type': 'ContentItem' | 'LtiLinkItem' | 'FileItem' | 'LtiLink' | string;
+    '@id': string;
+    mediaType: string;
+    text: string;
+    title: string;
+    url: string;
+    thumbnail: {
+        '@id': string;
+        height: number | string;
+        width: number | string;
+    };
+    placementAdvice: {
+        displayHeight: number | string;
+        displayWidth: number | string;
+        presentationDocumentTarget: 'window' | 'embed' | 'iframe' | string;
+    };
+    canvasURL: string;
+    class: string;
+    custom: StudioContentItemCustomJson | unknown;
+}>;

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/Lti13ContentItemJson.d.ts

@@ -0,0 +1,55 @@
+import { DeepPartialNullable } from '../../../../util/DeepPartialNullable';
+export type Lti13ContentItemJson = HtmlFragmentContentItemJson | ImageContentItemJson | LinkContentItemJson | ResourceLinkContentItemJson | UnknownContentItemJson;
+export type UnknownContentItemJson = DeepPartialNullable<{
+    type: string;
+    [key: string]: any;
+}>;
+export type HtmlFragmentContentItemJson = DeepPartialNullable<{
+    type: 'html';
+    html: string;
+    title: string;
+    text: string;
+}>;
+export type ImageContentItemJson = DeepPartialNullable<{
+    type: 'image';
+    url: string;
+    title: string;
+    thumbnail: ContentItemThumbnailJson | string;
+    text: string;
+    width: number | string;
+    height: number | string;
+}>;
+export type BaseLinkContentItemJson = DeepPartialNullable<{
+    type: 'link' | 'ltiResourceLink';
+    url: string;
+    title: string;
+    text: string;
+    icon: unknown;
+    thumbnail: unknown;
+    iframe: ContentItemIframeJson;
+    custom: unknown;
+    lookup_uuid: string;
+}>;
+export type LinkContentItemJson = DeepPartialNullable<BaseLinkContentItemJson & {
+    type: 'link';
+}>;
+export type ResourceLinkContentItemJson = DeepPartialNullable<BaseLinkContentItemJson & {
+    type: 'ltiResourceLink';
+    lookup_uuid: string;
+}>;
+export type ContentItemThumbnailJson = DeepPartialNullable<{
+    url: string;
+    width: number | string;
+    height: number | string;
+}>;
+export declare function isContentItemThumbnailJson(input: any): input is ContentItemThumbnailJson & {
+    url: string;
+};
+export type ContentItemIframeJson = DeepPartialNullable<{
+    src: string;
+    width: number | string;
+    height: number | string;
+}>;
+export declare function isContentItemIframeJson(input: any): input is ContentItemIframeJson & {
+    src: string;
+};

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/RceLti13ContentItem.d.ts

@@ -0,0 +1,31 @@
+import { Lti13ContentItemJson } from './Lti13ContentItemJson';
+/**
+ * Represents an LTI 1.3 Deep Linking Content Item for purposes related to the Rich Content Editor.
+ *
+ * Use rceLti13ContentItemFromJson to create instances of this class.
+ */
+export declare abstract class RceLti13ContentItem<TJson extends object> {
+    readonly type: Lti13ContentItemJson['type'];
+    readonly json: TJson;
+    readonly context: RceLti13ContentItemContext;
+    constructor(type: Lti13ContentItemJson['type'], json: TJson, context: RceLti13ContentItemContext);
+    abstract buildTitle(): string | null | undefined;
+    abstract buildText(): string | null | undefined;
+    abstract buildUrl(): string | null | undefined;
+    abstract toHtmlString(): any;
+    private get untypedJson();
+    linkThumbnail(): string | undefined;
+    iframeTag(): string | undefined;
+    imageTag(src: string, width?: string | number | null, height?: string | number | null): string;
+    anchorTag(innerHTML: string | null | undefined): string;
+    get safeUrl(): string;
+}
+export interface RceLti13ContentItemClass<T extends Lti13ContentItemJson> {
+    new (json: T, context: RceLti13ContentItemContext): RceLti13ContentItem<T>;
+}
+export interface RceLti13ContentItemContext {
+    ltiIframeAllowPolicy: string | null;
+    containingCanvasLtiToolId: string | null;
+    ltiEndpoint: string | null;
+    selection: string | null;
+}

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/models/BaseLinkContentItem.d.ts

@@ -0,0 +1,19 @@
+import { RceLti13ContentItem } from '../RceLti13ContentItem';
+import { BaseLinkContentItemJson } from '../Lti13ContentItemJson';
+export default class BaseLinkContentItem<TJson extends BaseLinkContentItemJson> extends RceLti13ContentItem<TJson> {
+    toHtmlString(): string | undefined;
+    linkText(): string | undefined;
+    linkBody(): string | undefined;
+    buildText(): string | null | undefined;
+    buildUrl(): string | null | undefined;
+    buildTitle(): string | null | undefined;
+    get icon(): unknown;
+    get thumbnail(): unknown;
+    get iframe(): import("../../../../../util/DeepPartialNullable").DeepPartialNullable<import("../../../../../util/DeepPartialNullable").DeepPartialNullable<{
+        src: string;
+        width: number | string;
+        height: number | string;
+    }>> | null | undefined;
+    get custom(): unknown;
+    get lookup_uuid(): string | null | undefined;
+}

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/models/HtmlFragmentContentItem.d.ts

@@ -0,0 +1,11 @@
+import { RceLti13ContentItem, RceLti13ContentItemContext } from '../RceLti13ContentItem';
+import { HtmlFragmentContentItemJson } from '../Lti13ContentItemJson';
+export default class HtmlFragmentContentItem extends RceLti13ContentItem<HtmlFragmentContentItemJson> {
+    static readonly type = "html";
+    constructor(json: HtmlFragmentContentItemJson, context: RceLti13ContentItemContext);
+    get html(): string | null | undefined;
+    buildTitle(): string | null | undefined;
+    buildText(): string | null | undefined;
+    buildUrl(): undefined;
+    toHtmlString(): string | null | undefined;
+}

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/models/ImageContentItem.d.ts

@@ -0,0 +1,17 @@
+import { RceLti13ContentItem, RceLti13ContentItemContext } from '../RceLti13ContentItem';
+import { ImageContentItemJson } from '../Lti13ContentItemJson';
+export default class ImageContentItem extends RceLti13ContentItem<ImageContentItemJson> {
+    static readonly type = "image";
+    constructor(json: ImageContentItemJson, context: RceLti13ContentItemContext);
+    buildUrl(): string | null | undefined;
+    buildTitle(): string | null | undefined;
+    get thumbnail(): string | import("../../../../../util/DeepPartialNullable").DeepPartialNullable<{
+        url: string;
+        width: number | string;
+        height: number | string;
+    }> | null | undefined;
+    buildText(): string | null | undefined;
+    get width(): string | number | null | undefined;
+    get height(): string | number | null | undefined;
+    toHtmlString(): string;
+}

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/models/LinkContentItem.d.ts

@@ -0,0 +1,7 @@
+import BaseLinkContentItem from './BaseLinkContentItem';
+import { RceLti13ContentItemContext } from '../RceLti13ContentItem';
+import { LinkContentItemJson } from '../Lti13ContentItemJson';
+export default class LinkContentItem extends BaseLinkContentItem<LinkContentItemJson> {
+    static readonly type = "link";
+    constructor(json: LinkContentItemJson, context: RceLti13ContentItemContext);
+}

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/models/ResourceLinkContentItem.d.ts

@@ -0,0 +1,9 @@
+import BaseLinkContentItem from './BaseLinkContentItem';
+import { ResourceLinkContentItemJson } from '../Lti13ContentItemJson';
+import { RceLti13ContentItemContext } from '../RceLti13ContentItem';
+export default class ResourceLinkContentItem extends BaseLinkContentItem<ResourceLinkContentItemJson> {
+    static readonly type = "ltiResourceLink";
+    constructor(json: ResourceLinkContentItemJson, context: RceLti13ContentItemContext);
+    toHtmlString(): string | undefined;
+    buildUrl(): string | null;
+}

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/processEditorContentItems.d.ts

@@ -0,0 +1,13 @@
+import { Lti13ContentItemJson } from './Lti13ContentItemJson';
+import { ExternalToolsEnv } from '../ExternalToolsEnv';
+export default function processEditorContentItems(event: {
+    data?: {
+        content_items?: Lti13ContentItemJson[] | null;
+        ltiEndpoint?: string | null;
+        replaceEditorContents?: boolean | null;
+        msg?: string | null;
+        errorMsg?: string | null;
+    };
+}, env: ExternalToolsEnv, dialog: {
+    close(): any;
+} | null): void;

package/es/rce/plugins/instructure_rce_external_tools/lti13-content-items/rceLti13ContentItemFromJson.d.ts

@@ -0,0 +1,12 @@
+import { Lti13ContentItemJson } from './Lti13ContentItemJson';
+import { RceLti13ContentItem, RceLti13ContentItemContext } from './RceLti13ContentItem';
+/**
+ * Creates an RceLti13ContentItem from the given JSON, or null if the type isn't supported.
+ *
+ * Note: this function would ideally be a static member of RceLti13ContentItem, but that creates a circular dependency
+ *       with the implementations of the base class, so it needs to be in a separate module.
+ *
+ * @param itemJson
+ * @param context
+ */
+export declare function rceLti13ContentItemFromJson<TJson extends Lti13ContentItemJson>(itemJson: TJson, context: RceLti13ContentItemContext): RceLti13ContentItem<TJson> | null;

package/es/rce/plugins/instructure_rce_external_tools/plugin.d.ts

@@ -0,0 +1,9 @@
+import { ExternalToolsEditor } from '../../types';
+/**
+ * This plugin adds the "Apps" toolbar button and the "Apps" menu item. It is a rewrite of 'instructure_external_tools'
+ * to live fully in the canvas-rce package. It supports running in an iframe as part of an LTI tool, such as
+ * new quizzes.
+ *
+ * @param editor
+ */
+export declare function initExternalToolsLocalPlugin(editor: ExternalToolsEditor): void;

package/es/rce/plugins/instructure_rce_external_tools/util/addParentFrameContextToUrl.d.ts

@@ -0,0 +1 @@
+export declare function addParentFrameContextToUrl(inputUrlStr: string | null | undefined, containingCanvasLtiToolId: string | null | undefined): string | null;

package/es/rce/plugins/instructure_rce_external_tools/util/externalToolsForToolbar.d.ts

@@ -0,0 +1,2 @@
+import type { ExternalToolData } from '../../../types';
+export declare function externalToolsForToolbar<T extends ExternalToolData>(tools: T[]): T[];

package/es/rce/plugins/instructure_record/AudioOptionsTray/TrayController.d.ts

@@ -0,0 +1,17 @@
+export const CONTAINER_ID: "instructure-audio-options-tray-container";
+export default class TrayController {
+    _isOpen: boolean;
+    _shouldOpen: boolean;
+    _editor: any;
+    _audioContainer: any;
+    get container(): HTMLElement;
+    get isOpen(): boolean;
+    showTrayForEditor(editor: any): void;
+    hideTrayForEditor(editor: any): void;
+    _dismissTray(): void;
+    _resetController(): Node;
+    _applyAudioOptions(audioOptions: any): any;
+    requestSubtitlesFromIframe(cb: any): void;
+    _subtitleListener: AbortController | undefined;
+    _renderTray(trayProps: any): void;
+}

package/es/rce/plugins/instructure_record/AudioOptionsTray/index.d.ts

@@ -0,0 +1,41 @@
+declare function AudioOptionsTray({ open, onEntered, onExited, onDismiss, onSave, trayProps, audioOptions, requestSubtitlesFromIframe, }: {
+    open: any;
+    onEntered: any;
+    onExited: any;
+    onDismiss: any;
+    onSave: any;
+    trayProps: any;
+    audioOptions: any;
+    requestSubtitlesFromIframe: any;
+}): React.JSX.Element;
+declare namespace AudioOptionsTray {
+    namespace propTypes {
+        export { func as onEntered };
+        export { func as onExited };
+        export { func as onDismiss };
+        export { func as onSave };
+        export let open: import("prop-types").Validator<boolean>;
+        export { func as requestSubtitlesFromIframe };
+        export let trayProps: import("prop-types").Validator<NonNullable<import("prop-types").InferProps<{
+            host: import("prop-types").Validator<string>;
+            jwt: import("prop-types").Validator<string>;
+        }>>>;
+        export let audioOptions: import("prop-types").Validator<NonNullable<import("prop-types").InferProps<{
+            id: import("prop-types").Validator<string>;
+            titleText: import("prop-types").Validator<string>;
+            tracks: import("prop-types").Requireable<(import("prop-types").InferProps<{
+                locale: import("prop-types").Validator<string>;
+            }> | null | undefined)[]>;
+        }>>>;
+    }
+    namespace defaultProps {
+        let onEntered: null;
+        let onExited: null;
+        let onDismiss: null;
+        let onSave: null;
+        function requestSubtitlesFromIframe(): void;
+    }
+}
+export default AudioOptionsTray;
+import React from 'react';
+import { func } from 'prop-types';