@nxtedition/types 23.1.2 → 23.1.4

package/dist/nxtpression.d.ts

@@ -58,6 +58,7 @@ declare interface AssetCreatedProvidedRecord {
 
 declare interface AssetDaemonRecord {
     "user-notify"?: boolean;
+    validate?: boolean;
 }
 
 declare interface AssetDaemonUserNotifyStateRecord {
@@ -65,6 +66,11 @@ declare interface AssetDaemonUserNotifyStateRecord {
     version?: number;
 }
 
+declare interface AssetDaemonValidateStateRecord {
+    since?: string | 0 | null;
+    version?: number;
+}
+
 declare interface AssetDeadlinesRecord {
     value?: Nxtpression<string, {
         id: string;
@@ -173,6 +179,12 @@ declare interface AssetFileRefsProvidedRecord {
     value?: string[];
 }
 
+declare interface AssetHttpRecord {
+    whitelist?: string[] | null;
+    blacklist?: string[] | null;
+    allowImport?: boolean;
+}
+
 declare interface AssetIconRecord {
     value?: Nxtpression<string, {
         id: string;
@@ -333,6 +345,7 @@ declare interface AssetRecords {
     "asset.tags": AssetTagsRecord;
     "asset.title": AssetTitleRecord;
     "asset.types": AssetTypesRecord;
+    "asset.http": AssetHttpRecord;
 }
 
 declare interface AssetRef {
@@ -399,6 +412,38 @@ declare interface AuthDomainRecords {
     ":auth": AuthDomainRecord;
 }
 
+declare interface BaseSchemaProperty<Value = unknown> {
+    domain?: string;
+    path?: string;
+    /** Specifying what type of data will be entered into the field. */
+    type?: "array" | "asset" | "boolean" | "datetime" | "number" | "string" | "object" | "rpc" | undefined;
+    /** User-friendly title of the property. This will be used as the field's label in the UI. */
+    title?: string;
+    description?: string;
+    /** If present, indicates that the user must specify a value for the asset to be treated as valid. */
+    required?: boolean;
+    oneOf?: Array<BaseSchemaProperty>;
+    anyOf?: Array<BaseSchemaProperty>;
+    enum?: ReadonlyArray<Value>;
+    widget?: WidgetType | WidgetOptions;
+    placeholder?: string;
+    helpText?: string;
+    invalid?: boolean;
+    emptyValue?: Value;
+    minItems?: number;
+    maxItems?: number;
+    items?: BaseSchemaProperty<Value>;
+    properties?: Record<string, BaseSchemaProperty<unknown>>;
+    computed?: Nxtpression<Value>;
+    /** An object specifying where to index the data. Adding this will effectively make the data searchable. */
+    index?: {
+        /** A string specifying the user-friendly title of the search property. This is what users will see when creating search filters and bookmarks. */
+        label: string;
+        /** A string specifying where to store the data in the search index. Note that this should be a globally unique value in the system. Typically you'd use `{domain}.{path}` and you should prefer English in camel case */
+        path: string;
+    };
+}
+
 declare interface BundleDomainRecords {
     [":bundle"]: BundleRecord;
     [":bundle.revisions"]: BundleRevisionsRecord;
@@ -648,23 +693,30 @@ declare interface DeviceDomainStatusRecord {
     version?: string;
 }
 
-declare interface DomainRecords extends AssetDomainRecords, AuthDomainRecords, BundleDomainRecords, CalendarEventDomainRecords, CloneDomainRecords, CommentReactionDomainRecords, CommentReadMarkDomainRecords, CommentDomainRecords, ConditionDomainRecords, ConnectionDomainRecords, ContactDomainRecords, DeepstreamDomainRecords, DesignDomainRecords, DeviceDomainRecords, EditDomainRecords, EventDomainRecords, FileDomainRecords, FolderDomainRecords, GeneralDomainRecords, HarvestDomainRecords, IngestclipDomainRecords, IngestScheduleDomainRecords, MediaDomainRecords, MonitorDomainRecords, NoteDomainRecords, PanelDomainRecords, PermissionDomainRecords, PipelinePresetDomainRecords, PipelineDomainRecords, PlanningDomainRecords, PrompterDomainRecords, PublishDomainRecords, PublishedDomainRecords, RenderPresetDomainRecords, RenderDomainRecords, RevsDomainRecords, RoleDomainRecords, ScriptDomainRecords, SearchDomainRecords, SettingsDomainRecords, ShotboxDomainRecords, StoryboardDomainRecords, SubtitleStyleDomainRecords, SubtitleDomainRecords, TemplateDomainRecords, UserNotificationStatusDomainRecords, UserNotificationDomainRecords, UserDomainRecords, UsernameDomainRecords {
+declare interface DomainRecords extends AssetDomainRecords, AuthDomainRecords, BundleDomainRecords, CalendarEventDomainRecords, CloneDomainRecords, CommentReactionDomainRecords, CommentReadMarkDomainRecords, CommentDomainRecords, ConditionDomainRecords, ConnectionDomainRecords, ContactDomainRecords, DeepstreamDomainRecords, DesignDomainRecords, DeviceDomainRecords, EditDomainRecords, EventDomainRecords, FileDomainRecords, FolderDomainRecords, GalleryDomainRecords, GeneralDomainRecords, HarvestDomainRecords, IngestclipDomainRecords, IngestScheduleDomainRecords, MediaDomainRecords, MonitorDomainRecords, NoteDomainRecords, PanelDomainRecords, PermissionDomainRecords, PipelinePresetDomainRecords, PipelineDomainRecords, PlanningDomainRecords, PrompterDomainRecords, PublishDomainRecords, PublishedDomainRecords, RenderPresetDomainRecords, RenderDomainRecords, RevsDomainRecords, RoleDomainRecords, SchemaDomainRecords, ScriptDomainRecords, SearchDomainRecords, SettingsDomainRecords, ShotboxDomainRecords, StorageDomainRecords, StoryboardDomainRecords, StreamDomainRecords, SubtitleStyleDomainRecords, SubtitleDomainRecords, TemplateDomainRecords, UserNotificationStatusDomainRecords, UserNotificationDomainRecords, UserDomainRecords, UsernameDomainRecords {
 }
 
 declare type Dynamic = false | string[];
 
+declare interface DynamicPanelProperty extends DynamicPropertyBase, Omit<PanelProperty, "path" | "domain"> {
+    /** ID of the panel asset that defines this property */
+    panel: string;
+}
+
 /**
  * Dynamic property definition.
  * Properties come from :panel assets or :schema assets.
  */
-declare interface DynamicProperty extends Omit<PanelProperty, "path">, Omit<SchemaProperty, "path"> {
-    /** ID of the panel asset that defines this property (for panel-sourced properties) */
-    panel?: string;
-    /** ID of the schema asset that defines this property (for schema-sourced properties) */
-    schema?: string;
-    /** List of asset types this property supports */
-    supports: string[];
+declare type DynamicProperty = DynamicPanelProperty | DynamicSchemaProperty;
+
+declare interface DynamicPropertyBase {
     path: string;
+    domain: string;
+}
+
+declare interface DynamicSchemaProperty extends DynamicPropertyBase, Omit<SchemaProperty, "path" | "domain"> {
+    /** ID of the schema asset that defines this property */
+    schema: string;
 }
 
 declare interface EditDomainRecords {
@@ -694,6 +746,10 @@ declare interface EmptyConnectionRecord extends ConnectionBase {
     type?: null;
 }
 
+declare type EmptyObject = {
+    [emptyObjectSymbol]?: never;
+};
+
 /**
  Represents a strictly empty plain object, the `{}` value.
 
@@ -711,8 +767,11 @@ declare interface EmptyConnectionRecord extends ConnectionBase {
 
  // With `EmptyObject` only the first case is valid.
  const bar1: EmptyObject = {}; // Pass
- const bar2: EmptyObject = 42; // Fail
- const bar3: EmptyObject = []; // Fail
+ // @ts-expect-error
+ const bar2: EmptyObject = []; // Fail
+ // @ts-expect-error
+ const bar3: EmptyObject = 42; // Fail
+ // @ts-expect-error
  const bar4: EmptyObject = {a: 1}; // Fail
  ```
 
@@ -720,10 +779,12 @@ declare interface EmptyConnectionRecord extends ConnectionBase {
 
  @category Object
  */
-declare type EmptyObject = {[emptyObjectSymbol]?: never};
+declare type EmptyObject_2 = {[emptyObjectSymbol_2]?: never};
 
 declare const emptyObjectSymbol: unique symbol;
 
+declare const emptyObjectSymbol_2: unique symbol;
+
 declare interface EmptyPublishDef extends PublishDef<null> {
     publish: EmptyPublishRecord;
 }
@@ -755,6 +816,7 @@ declare interface EventDomainRecords {
     ":event.duration?": EventDurationRecord;
     ":event.children?": EventChildrenRecord;
     ":event.props?": EventPropsRecord;
+    ":event.stats?": EventStatsRecord;
 }
 
 declare interface EventDurationRecord {
@@ -780,6 +842,7 @@ declare interface EventOverlayRecord {
 declare type EventProps = {
     source?: string;
     cueCard?: boolean | string;
+    printRundownColor?: string;
     startTime?: number;
     shotboxGroup?: string | string[];
     shotboxVisible?: boolean;
@@ -788,21 +851,27 @@ declare type EventProps = {
 declare type EventPropsRecord = EventProps & Record<Exclude<string, keyof EventProps>, JsonValue>;
 
 declare interface EventRecord {
-    start?: number;
-    end?: number;
-    duration?: number;
+    start?: number | null;
+    end?: number | null;
+    duration?: number | null;
+    position?: string;
     text?: string;
     lang?: string;
     style?: string;
     styleOverrides?: SubtitleEventStyleOverrides;
 }
 
+declare interface EventStatsRecord {
+    type?: string;
+}
+
 declare interface EventTemplateRecord {
     mixin?: string[];
     properties?: object;
     layout?: {
         title?: string;
     };
+    controller?: string;
 }
 
 declare type ExactRecords = MiscRecords & MediaRecords & AssetRecords & MonitorRecords & StorageRecords;
@@ -957,9 +1026,11 @@ declare interface FileConnectionSmbRecord extends FileConnectionBase {
     protocol?: "smb";
     host?: string;
     share?: string;
+    root?: string;
     workgroup?: string;
     username?: string;
     password?: string;
+    createFolders?: boolean;
 }
 
 declare interface FileDomainRecords {
@@ -1114,14 +1185,14 @@ declare interface FolderItemsDomainRecord {
     value: string[];
 }
 
-declare interface FontFace_2 {
+declare interface FontFace {
     name: string;
     family: string;
     asset: string;
     url: string;
     weight: number;
     style: "normal" | "italic";
-    ranges: Range_2[];
+    ranges: Range[];
 }
 
 declare interface FormattedTextNodeContent {
@@ -1131,6 +1202,16 @@ declare interface FormattedTextNodeContent {
     format?: number;
 }
 
+declare interface GalleryDomainRecord {
+    sources?: {
+        program?: string;
+    };
+}
+
+declare interface GalleryDomainRecords {
+    ":gallery": GalleryDomainRecord;
+}
+
 declare interface GeneralAssetRecord {
     title?: string;
     tags?: string;
@@ -1305,7 +1386,7 @@ declare interface HttpConnectionResponseHandler<ResOutput = undefined> {
 
  @example
  ```
- import {If} from 'type-fest';
+ import type {If} from 'type-fest';
 
  type A = If<true, 'yes', 'no'>;
  //=> 'yes'
@@ -1325,7 +1406,7 @@ declare interface HttpConnectionResponseHandler<ResOutput = undefined> {
 
  @example
  ```
- import {If, IsAny, IsNever} from 'type-fest';
+ import type {If, IsAny, IsNever} from 'type-fest';
 
  type A = If<IsAny<unknown>, 'is any', 'not any'>;
  //=> 'not any'
@@ -1336,7 +1417,7 @@ declare interface HttpConnectionResponseHandler<ResOutput = undefined> {
 
  @example
  ```
- import {If, IsEqual} from 'type-fest';
+ import type {If, IsEqual} from 'type-fest';
 
  type IfEqual<T, U, IfBranch, ElseBranch> = If<IsEqual<T, U>, IfBranch, ElseBranch>;
 
@@ -1347,6 +1428,41 @@ declare interface HttpConnectionResponseHandler<ResOutput = undefined> {
  //=> 'not equal'
  ```
 
+ Note: Sometimes using the `If` type can make an implementation non–tail-recursive, which can impact performance. In such cases, it’s better to use a conditional directly. Refer to the following example:
+
+ @example
+ ```
+ import type {If, IsEqual, StringRepeat} from 'type-fest';
+
+ type HundredZeroes = StringRepeat<'0', 100>;
+
+ // The following implementation is not tail recursive
+ type Includes<S extends string, Char extends string> =
+ 	S extends `${infer First}${infer Rest}`
+ 		? If<IsEqual<First, Char>,
+ 			'found',
+ 			Includes<Rest, Char>>
+ 		: 'not found';
+
+ // Hence, instantiations with long strings will fail
+ // @ts-expect-error
+ type Fails = Includes<HundredZeroes, '1'>;
+ //           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ // Error: Type instantiation is excessively deep and possibly infinite.
+
+ // However, if we use a simple conditional instead of `If`, the implementation becomes tail-recursive
+ type IncludesWithoutIf<S extends string, Char extends string> =
+ 	S extends `${infer First}${infer Rest}`
+ 		? IsEqual<First, Char> extends true
+ 			? 'found'
+ 			: IncludesWithoutIf<Rest, Char>
+ 		: 'not found';
+
+ // Now, instantiations with long strings will work
+ type Works = IncludesWithoutIf<HundredZeroes, '1'>;
+ //=> 'not found'
+ ```
+
  @category Type Guard
  @category Utilities
  */
@@ -1430,7 +1546,7 @@ declare type InternalIsUnion<T, U = T> =
 	IsNever<T> extends true
 		? false
 		: T extends any
-			? [U] extends [T]
+			? IsEqual<U, T> extends true
 				? false
 				: true
 			: never
@@ -1450,14 +1566,53 @@ declare type InternalIsUnion<T, U = T> =
  import type {IsEmptyObject} from 'type-fest';
 
  type Pass = IsEmptyObject<{}>; //=> true
- type Fail = IsEmptyObject<[]>; //=> false
- type Fail = IsEmptyObject<null>; //=> false
+ type Fail1 = IsEmptyObject<[]>; //=> false
+ type Fail2 = IsEmptyObject<null>; //=> false
  ```
 
- @see EmptyObject
+ @see {@link EmptyObject}
  @category Object
  */
-declare type IsEmptyObject<T> = T extends EmptyObject ? true : false;
+declare type IsEmptyObject<T> = T extends EmptyObject_2 ? true : false;
+
+/**
+ Returns a boolean for whether the two given types are equal.
+
+ @link https://github.com/microsoft/TypeScript/issues/27024#issuecomment-421529650
+ @link https://stackoverflow.com/questions/68961864/how-does-the-equals-work-in-typescript/68963796#68963796
+
+ Use-cases:
+ - If you want to make a conditional branch based on the result of a comparison of two types.
+
+ @example
+ ```
+ import type {IsEqual} from 'type-fest';
+
+ // This type returns a boolean for whether the given array includes the given item.
+ // `IsEqual` is used to compare the given array at position 0 and the given item and then return true if they are equal.
+ type Includes<Value extends readonly any[], Item> =
+ 	Value extends readonly [Value[0], ...infer rest]
+ 		? IsEqual<Value[0], Item> extends true
+ 			? true
+ 			: Includes<rest, Item>
+ 		: false;
+ ```
+
+ @category Type Guard
+ @category Utilities
+ */
+declare type IsEqual<A, B> =
+	[A] extends [B]
+		? [B] extends [A]
+			? _IsEqual<A, B>
+			: false
+		: false;
+
+declare type _IsEqual<A, B> =
+	(<G>() => G extends A & G | G ? 1 : 2) extends
+	(<G>() => G extends B & G | G ? 1 : 2)
+		? true
+		: false;
 
 /**
  Returns a boolean for whether the given type is `never`.
@@ -1472,29 +1627,41 @@ declare type IsEmptyObject<T> = T extends EmptyObject ? true : false;
  ```
  import type {IsNever, And} from 'type-fest';
 
- // https://github.com/andnp/SimplyTyped/blob/master/src/types/strings.ts
- type AreStringsEqual<A extends string, B extends string> =
- 	And<
- 		IsNever<Exclude<A, B>> extends true ? true : false,
- 		IsNever<Exclude<B, A>> extends true ? true : false
- 	>;
-
- type EndIfEqual<I extends string, O extends string> =
- 	AreStringsEqual<I, O> extends true
- 		? never
- 		: void;
-
- function endIfEqual<I extends string, O extends string>(input: I, output: O): EndIfEqual<I, O> {
- 	if (input === output) {
- 		process.exit(0);
- 	}
- }
-
- endIfEqual('abc', 'abc');
+ type A = IsNever<never>;
+ //=> true
+
+ type B = IsNever<any>;
+ //=> false
+
+ type C = IsNever<unknown>;
+ //=> false
+
+ type D = IsNever<never[]>;
+ //=> false
+
+ type E = IsNever<object>;
+ //=> false
+
+ type F = IsNever<string>;
+ //=> false
+ ```
+
+ @example
+ ```
+ import type {IsNever} from 'type-fest';
+
+ type IsTrue<T> = T extends true ? true : false;
+
+ // When a distributive conditional is instantiated with `never`, the entire conditional results in `never`.
+ type A = IsTrue<never>;
  //=> never
 
- endIfEqual('abc', '123');
- //=> void
+ // If you don't want that behaviour, you can explicitly add an `IsNever` check before the distributive conditional.
+ type IsTrueFixed<T> =
+ 	IsNever<T> extends true ? false : T extends true ? true : false;
+
+ type B = IsTrueFixed<never>;
+ //=> false
  ```
 
  @category Type Guard
@@ -1534,13 +1701,6 @@ declare type KeyedProvidedDomainRecords = {
     [Domain in ProvidedDomainKeys as `${string}${Domain}${string}`]: GettablePossibleEmpty<DomainRecords[Domain]>;
 };
 
-declare interface KeymapSetting {
-    title?: string;
-    sequence?: string;
-}
-
-declare type LayoutWidget = WidgetType | WidgetItem;
-
 declare interface LinkNodeContent {
     type: "link" | "autolink";
     children: FormattedTextNodeContent[];
@@ -1623,6 +1783,11 @@ declare interface MediaDomainRecords {
     ":media.probe?": MediaProbeRecord;
     ":media.updateSubtitles?": MediaDomainUpdateSubtitlesRecord;
     ":media.updateGraphics?": MediaDomainUpdateGraphicsRecord;
+    ":media.revisions": MediaDomainRevisionsRecord;
+}
+
+declare interface MediaDomainRevisionsRecord {
+    [revisionId: string]: RenderSceneObject;
 }
 
 declare interface MediaDomainUpdateGraphicsRecord {
@@ -1638,8 +1803,8 @@ declare interface MediaFontRecord {
 }
 
 declare interface MediaFonts {
-    fontFaces?: FontFace_2[];
-    fontFamilyNames?: Array<FontFace_2["family"]>;
+    fontFaces?: FontFace[];
+    fontFamilyNames?: Array<FontFace["family"]>;
 }
 
 declare interface MediaProbeRecord {
@@ -1770,6 +1935,7 @@ declare type Minimum<Value extends number | bigint> = TagBase<{
 declare interface MiscRecords {
     "asset-daemon": AssetDaemonRecord;
     "asset-daemon:user-notify.state": AssetDaemonUserNotifyStateRecord;
+    "asset-daemon:validate.state": AssetDaemonValidateStateRecord;
     "deepstream-replicator.stats?": DeepstreamReplicatorStatsRecord;
 }
 
@@ -1949,7 +2115,7 @@ declare interface NxtError {
     errors?: NxtError[] | null;
 }
 
-declare type Nxtpression<ReturnValue = unknown, Context extends object = object> = {
+declare type Nxtpression<ReturnValue = unknown, Context extends Record<string, unknown> = Record<string, unknown>> = {
     /**
      * TS-HACK: this property doesn't really exist on the nxtpression string,
      * it is only here to make sure the generic Context won't get stripped.
@@ -2009,6 +2175,7 @@ declare interface NxtStatusMessage {
         title: string;
         url: string;
     };
+    data?: unknown;
 }
 
 declare interface NxtStatusNode extends NxtStatusObject {
@@ -2227,8 +2394,16 @@ declare interface Operator<T, R> {
 declare interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {
 }
 
+declare type PageOrientation = "landscape" | "portrait";
+
+declare type PageSize = "A5" | "A4" | "A3";
+
 declare interface PanelDomainPanelRecord {
     title?: string;
+    /**
+     * - If an array: interpreted as a list of supported asset types
+     * - If a string: interpreted as the ID of a search which contains supported assets
+     */
     supports?: string[] | string;
     priority?: number;
     editorPriority?: number;
@@ -2236,8 +2411,8 @@ declare interface PanelDomainPanelRecord {
         [key: string]: PanelProperty;
     };
     layout?: {
-        panel?: PanelLayout;
-        editor?: PanelLayout;
+        panel?: WidgetLayout;
+        editor?: WidgetLayout;
     };
     filter?: Nxtpression;
     expand?: Nxtpression;
@@ -2247,47 +2422,7 @@ declare interface PanelDomainRecords {
     ":panel": PanelDomainPanelRecord;
 }
 
-declare type PanelLayout = string | PanelLayoutDivider | PanelLayoutItem | PanelLayout[];
-
-declare interface PanelLayoutDivider {
-    type: "divider";
-    title?: string;
-}
-
-declare interface PanelLayoutItem {
-    property: string;
-    width?: string | number;
-    widget?: LayoutWidget;
-}
-
-declare interface PanelProperty<Value = unknown> {
-    /** Specifying what type of data will be entered into the field. */
-    type: "array" | "asset" | "boolean" | "datetime" | "number" | "string" | "object" | "rpc";
-    /** User-friendly title of the property. This will be used as the field's label in the UI. */
-    title?: string;
-    description?: string;
-    domain?: string;
-    path?: string;
-    computed?: Nxtpression<Value>;
-    /** An object specifying where to index the data. Adding this will effectively make the data searchable. */
-    index?: {
-        /** A string specifying the user-friendly title of the search property. This is what users will see when creating search filters and bookmarks. */
-        label: string;
-        /** A string specifying where to store the data in the search index. Note that this should be a globally unique value in the system. Typically you'd use `{domain}.{path}` and you should prefer English in camel case */
-        path: string;
-    };
-    /** If present, indicates that the user must specify a value for the asset to be treated as valid. */
-    required?: boolean;
-    oneOf?: Array<{
-        const?: Value;
-        title?: string;
-    }>;
-    anyOf?: Array<{
-        const?: Value;
-        title?: string;
-    }>;
-    enum?: Value[];
-}
+declare type PanelProperty<Value = unknown> = BaseSchemaProperty<Value>;
 
 declare interface ParagraphNodeContent extends ElementNodeContent {
     type: "paragraph";
@@ -2384,6 +2519,39 @@ declare interface PlanningRecord {
     deadline?: string | null;
 }
 
+declare type PrintOptionalScriptNodes = "event" | "event-data" | "comment" | "heading" | "list" | "quote" | "paragraph" | "horizontalrule";
+
+declare type PrintOptions = PrintScriptOptions | PrintRundownOptions;
+
+declare interface PrintOptionsBase {
+    title: string;
+    horizontalMargin: number;
+    pageSize: PageSize;
+    orientation: PageOrientation;
+    fontSize: number;
+    fontFamily?: string;
+    hide: PrintOptionalScriptNodes[];
+}
+
+declare interface PrintRundownColumn {
+    key: "id" | "title" | "time" | "duration" | "position" | "accDuration" | "type";
+    label: string;
+    width: string;
+    textAlign: "right" | "left" | "center";
+}
+
+declare interface PrintRundownOptions extends PrintOptionsBase {
+    type: "rundown";
+    columns: PrintRundownColumn[];
+    rangeStart?: number;
+    rangeEnd?: number;
+    hide: Exclude<PrintOptionalScriptNodes, "event-data">[];
+}
+
+declare interface PrintScriptOptions extends PrintOptionsBase {
+    type: "script";
+}
+
 declare interface PromotedTag {
     name: string | null;
     icon: string | null;
@@ -2507,7 +2675,7 @@ declare interface QuoteNodeContent extends ElementNodeContent {
     type: "quote";
 }
 
-declare type Range_2 = [
+declare type Range = [
 number,
 number
 ];
@@ -2574,10 +2742,60 @@ declare interface RenderDomainRecords {
 }
 
 declare interface RenderDomainResultRecord {
-    [key: string]: unknown;
+    id?: string;
     url?: string;
+    files?: string[];
+    refs?: Array<{
+        file?: string;
+        offset?: number;
+        start?: number | null;
+        end?: number | null;
+    }>;
     result?: unknown;
     error?: null | Record<string, unknown> | Array<Record<string, unknown>>;
+    extension?: string;
+    extensions?: string[];
+    type?: string;
+    format?: string;
+    formatName?: string;
+    mimeType?: string;
+    duration?: number;
+    estimatedDuration?: number | null;
+    video?: {
+        codec?: string;
+        width?: number;
+        height?: number;
+        interlaced?: boolean;
+        alpha?: boolean | string;
+        sar?: string | null;
+        dar?: string;
+        framerate?: number;
+        format?: string;
+        encoder?: string;
+        codecName?: string;
+    } | null;
+    audio?: {
+        codec?: string;
+        codecName?: string;
+        format?: string;
+        channels?: number;
+        samplerate?: number;
+        peaksPerSecond?: number;
+        streams?: number;
+        encoder?: string;
+    } | null;
+    language?: string;
+    transcribe?: {
+        engine?: string;
+        version?: string;
+        language?: string;
+    } | null;
+    pan?: number[];
+    translate?: {
+        engine?: string;
+        source?: string;
+        target?: string;
+    } | null;
 }
 
 declare interface RenderDomainSchedulersRecord {
@@ -2640,13 +2858,14 @@ declare interface RenderDomainStatsRecord {
     netTransferTotal?: number | null;
     cpu?: number | null;
     memory?: number | null;
-    activeCount: number | null;
-    totalCount: number | null;
+    activeCount?: number | null;
+    totalCount?: number | null;
     gpuStat?: RenderDomainGpuStats | null;
     cpuStat?: RenderDomainCpuStats | null;
     netStat?: RenderDomainNetStats | null;
     limits?: unknown;
     taskset?: string;
+    end?: number | null;
 }
 
 declare type RenderPreset = RenderPresetObject | string;
@@ -2695,36 +2914,103 @@ declare interface RenderQuery {
 
 declare type RenderScene = (RenderSceneObject | string) | (RenderSceneObject | string)[];
 
+/** true = premultiplied alpha, 'straight' = straight alpha, null/undefined = auto */
+declare type RenderSceneAlpha = boolean | "straight";
+
+declare interface RenderSceneCrop {
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+}
+
+declare interface RenderSceneFilters {
+    eq?: {
+        brightness?: number;
+        contrast?: number;
+        gamma?: number;
+        saturation?: number;
+    };
+    hue?: {
+        h?: number;
+        s?: number;
+        b?: number;
+    };
+    colorbalance?: {
+        rs?: number;
+        gs?: number;
+        bs?: number;
+        rm?: number;
+        gm?: number;
+        bm?: number;
+        rh?: number;
+        gh?: number;
+        bh?: number;
+    };
+}
+
+declare type RenderSceneInterlaced = false | "tff" | "bff";
+
 declare interface RenderSceneObject {
     id?: string;
     preset?: string;
     input?: {
         type?: string;
         file?: string | null;
+        video?: {
+            alpha?: RenderSceneAlpha | null;
+            interlaced?: RenderSceneInterlaced | null;
+        };
+        proxy?: string | null;
+        proxyManifest?: string | null;
+        proxyFile?: string | null;
+        manifest?: string | null;
     } | null;
     lang?: string;
     subtitle?: string;
-    subtitleTracks?: {
-        [trackId: string]: {
-            style?: string | null;
-            styleOverrides?: SubtitleStyle;
-        };
-    };
+    graphics?: string;
+    subtitleTracks?: RenderSceneSubtitleTracks;
     video?: {
-        crop?: {
-            x?: number;
-            y?: number;
-            width?: number;
-            height?: number;
-        };
+        filters?: RenderSceneFilters;
+        crop?: RenderSceneCrop;
+        orientation?: number;
+        /** @deprecated Use input.video.interlaced */
+        interlaced?: RenderSceneInterlaced | null;
+        /** @deprecated Use input.video.alpha */
+        alpha?: RenderSceneAlpha | null;
+    };
+    audio?: {
+        pan?: number[][];
     };
     start?: number;
     end?: number;
     transcribe?: {
         language?: string;
         pan?: number[];
+        diarization?: boolean;
     };
-}
+    /** @deprecated Use video.crop instead */
+    crop?: RenderSceneCrop;
+    /** @deprecated Use video.filters instead */
+    filters?: RenderSceneFilters;
+    /** @deprecated Use video.orientation instead */
+    orientation?: number;
+    /** @deprecated Use video.orientation instead */
+    rotate?: number;
+    /** @deprecated Use input.video.interlaced instead */
+    interlaced?: RenderSceneInterlaced | null;
+    /** @deprecated Use input.video.alpha instead */
+    alpha?: RenderSceneAlpha | null;
+}
+
+declare interface RenderSceneSubtitleTrack {
+    style?: string | null;
+    styleOverrides?: SubtitleStyle;
+}
+
+declare type RenderSceneSubtitleTracks = {
+    [trackId: string]: RenderSceneSubtitleTrack;
+};
 
 /**
  * 0 = Monthly
@@ -2766,20 +3052,52 @@ declare interface RevsRecord {
 }
 
 declare interface RoleDomainRecords {
+    ":role": RoleRecord;
+    ":role.users?": RoleUsersRecord;
     ":role.tags": RoleTagsRecord;
 }
 
+declare type RoleRecord = {
+    permissions?: Record<string, string[]>;
+};
+
 declare interface RoleTagsRecord {
     value: string[];
 }
 
+declare type RoleUsersRecord = {
+    value?: string[];
+};
+
 declare interface RpcPermission {
     type: "rpc";
     method: string;
     tags?: undefined;
 }
 
-declare interface SchemaProperty extends PanelProperty {
+declare interface SchemaDomainPanelRecord {
+    title?: string;
+    /**
+     * - If an array: interpreted as a list of supported asset types
+     * - If a string: interpreted as the ID of a search which contains supported assets
+     */
+    supports?: string[] | string;
+    domain?: string;
+    priority?: number;
+    properties?: {
+        [key: string]: SchemaProperty;
+    };
+    layout?: {
+        panel?: WidgetLayout;
+        editor?: WidgetLayout;
+    };
+}
+
+declare interface SchemaDomainRecords {
+    ":schema": SchemaDomainPanelRecord;
+}
+
+declare interface SchemaProperty<Value = unknown> extends BaseSchemaProperty<Value> {
     recordName?: Nxtpression<string, {
         id: string;
     }>;
@@ -2787,8 +3105,8 @@ declare interface SchemaProperty extends PanelProperty {
         id: string;
         value: unknown;
     }>;
-    default?: unknown;
-    const?: unknown;
+    default?: Value;
+    const?: Value;
 }
 
 /**
@@ -3008,6 +3326,18 @@ declare interface Settings {
         overrideUserContact?: boolean;
         overrideUserLogin?: boolean;
     };
+    graphics?: {
+        width?: number;
+        height?: number;
+    };
+    googleWhitelist?: Array<{
+        domain?: string;
+    }>;
+    googleUserRoles?: string[];
+    azureWhitelist?: Array<{
+        domain?: string;
+    }>;
+    azureUserRoles?: string[];
     module?: {
         editor?: string;
         tabs?: ModuleTabs;
@@ -3029,10 +3359,10 @@ declare interface Settings {
         map?: {
             clustering?: boolean;
             zoom?: number;
-            center?: {
-                lat?: number;
-                lon?: number;
-            };
+            center?: [
+            number,
+            number
+            ];
         };
         createMenu?: {
             sortOrder?: string[];
@@ -3085,6 +3415,7 @@ declare interface Settings {
             sortBy?: "index" | "title";
             showPreview?: boolean;
         };
+        contentMaxWidth?: number;
         colorTags?: PromotedTag[];
         readType?: "characters" | "words" | "wordsPerMinute";
         readRate?: number;
@@ -3117,44 +3448,20 @@ declare interface Settings {
         countFloatedDuration?: boolean;
     };
     history?: boolean;
-    keymap?: {
-        display?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        browser?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        gallery?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        global?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        player?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        script?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        codeEditor?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        bookmarks?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        edit?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        rundown?: {
-            [actionKey: string]: KeymapSetting;
-        };
-        segment?: {
-            [actionKey: string]: KeymapSetting;
-        };
-    };
+    keymap?: SettingsKeymap;
     media?: {
+        volume?: number;
+        muted?: boolean;
+        graphics?: boolean;
+        waveform?: boolean;
         defaultFrameRate?: number;
+        dropFrame?: boolean;
         placeholder?: string;
+        warnSubclipDuration?: number;
+        displayAspectRatioPresets?: Array<{
+            label?: string;
+            value?: string;
+        }>;
         guide?: {
             mask?: boolean;
             actionSafe?: boolean;
@@ -3294,6 +3601,7 @@ declare interface Settings {
     };
     print?: {
         fontFamilies?: string[];
+        presets?: Array<PrintOptions>;
     };
     hiddenPreviews?: Array<{
         id?: string;
@@ -3301,7 +3609,27 @@ declare interface Settings {
     }>;
     plugins?: {
         adobe?: {
+            videoBin?: string;
+            imageBin?: string;
+            audioBin?: string;
+            timelineBin?: string;
+            clipBin?: string;
+            downloadPath?: string;
+            renderPath?: string;
+            renderPresetPath?: string;
+            renderPresets?: string[];
+            videoRenderPreset?: string;
+            imageRenderPreset?: string;
+            audioRenderPreset?: string;
+            forceRender?: boolean;
             useProxies?: boolean;
+            deleteIntermediateFiles?: boolean;
+            bodymovin?: {
+                template?: string;
+            };
+        };
+        ograf?: {
+            template?: string;
         };
         rive?: {
             template?: string;
@@ -3311,6 +3639,7 @@ declare interface Settings {
     debug?: boolean;
     featurePreview?: {
         collections?: boolean;
+        aiMetadata?: boolean;
         semanticSearch?: boolean;
         ameRemoteRendering?: boolean;
     };
@@ -3332,6 +3661,8 @@ declare interface Settings {
         hideInAssetMenu?: boolean;
         assetRoute?: boolean;
         devWarnings?: boolean;
+        downloadFiles?: boolean;
+        supportPortal?: boolean;
         multiplexWebSockets?: boolean;
         systemHealth?: boolean;
         systemHealthIgnore?: boolean;
@@ -3375,8 +3706,14 @@ declare interface Settings {
         layout?: string;
     };
     performance?: {
-        /** List of message identifiers to ignore in overall health aggregation (format: "serviceName:messageText") */
-        ignoredMessages?: string[];
+        /** List of message identifiers to ignore warnings (format: "serviceName:messageText") */
+        ignoredWarnings?: string[];
+        /** List of message identifiers to ignore errors (format: "serviceName:messageText") */
+        ignoredErrors?: string[];
+    };
+    app?: {
+        enableUpdate?: boolean;
+        autoUpdate?: boolean;
     };
 }
 
@@ -3385,6 +3722,20 @@ declare interface SettingsDomainRecords {
     ":settings.node": SettingsNodeRecord;
 }
 
+declare type SettingsKeymap = Record<string, SettingsKeymapScope>;
+
+declare interface SettingsKeymapEntry {
+    title?: string;
+    sequence?: string | (string | [
+    string,
+    unknown
+    ])[] | null | undefined;
+    schema?: Record<string, any>;
+    stopCallback?: boolean;
+}
+
+declare type SettingsKeymapScope = Record<string, SettingsKeymapEntry>;
+
 declare type SettingsNodeRecord = Record<string, {
     collapsed: boolean;
     hidden: boolean;
@@ -3443,16 +3794,12 @@ declare interface ShotboxStreamGroup {
  ```
  import type {SingleKeyObject} from 'type-fest';
 
- const someFunction = <T>(parameter: SingleKeyObject<T>) => {};
+ declare function someFunction<T>(parameter: SingleKeyObject<T>): void;
 
- someFunction({
- 	value: true
- });
+ someFunction({value: true});
 
- someFunction({
- 	value: true,
- 	otherKey: true
- });
+ // @ts-expect-error
+ someFunction({value: true, otherKey: true});
  // Error: Argument of type '{value: boolean; otherKey: boolean}' is not assignable to parameter of type 'never'.ts(2345)
  ```
 
@@ -3467,6 +3814,48 @@ declare type Spread<T1, T2> = Omit<T2, keyof T1> & T1;
 
 declare type StatsRecord = Union["stats"];
 
+declare interface StorageDomainRecord {
+    zone: string;
+    hostname: string | null;
+    port?: number | null;
+    location?: string;
+    cache?: boolean | null;
+    allows?: string[];
+    capacity?: number | null;
+    rxBytesSecMax?: number | null;
+    txBytesSecMax?: number | null;
+    rxBytesSecLimit?: number | null;
+    txBytesSecLimit?: number | null;
+}
+
+declare interface StorageDomainRecords {
+    ":storage": StorageDomainRecord;
+    ":storage.stats": StorageStatsDomainRecord;
+    ":storage-zone": StorageZoneDomainRecord;
+}
+
+declare interface StorageFsStats {
+    concurrency?: number;
+    path?: string;
+    snapshot?: number | null;
+    available?: number;
+    free?: number;
+    used?: number;
+    size?: number;
+    state?: string;
+    [key: string]: unknown;
+}
+
+declare interface StorageIoQueues {
+    highest: number;
+    higher: number;
+    high: number;
+    normal: number;
+    low: number;
+    lower: number;
+    lowest: number;
+}
+
 declare interface StorageLocationsRecord {
     [key: string]: StorageLocationsRecordEntry;
 }
@@ -3496,6 +3885,58 @@ declare interface StorageRecords {
     "storage.zones?": StorageZonesRecord;
 }
 
+declare interface StorageS3Stats {
+    bucket?: string;
+    region?: string;
+    endpoint?: string;
+    path?: string;
+    storageClass?: string;
+    [key: string]: unknown;
+}
+
+declare interface StorageStatsDomainRecord {
+    id: string;
+    location: string;
+    timestamp: string;
+    type: string;
+    zone: string;
+    origin: string;
+    free: number | null;
+    size: number | null;
+    available: number | null;
+    cache: boolean | null;
+    capacity: number | null;
+    limiter: {
+        readBytesPerSecond: number | undefined;
+        writeBytesPerSecond: number | undefined;
+    };
+    http: {
+        downstreamConnected: number;
+        upstreamConnected: number;
+        pending: number;
+        completed: number;
+        failed: number;
+    };
+    io: {
+        read: {
+            bytesPerSecond: number;
+            pending: number;
+            queues: StorageIoQueues;
+        };
+        write: {
+            bytesPerSecond: number;
+            pending: number;
+            queues: StorageIoQueues;
+        };
+    };
+    fs?: StorageFsStats;
+    s3?: StorageS3Stats;
+}
+
+declare interface StorageZoneDomainRecord {
+    priority?: number;
+}
+
 declare interface StorageZonesRecord {
     [key: string]: {
         priority: number;
@@ -3526,6 +3967,91 @@ declare interface StoryboardDomainRecords {
     ":storyboard.ancestors?": StoryboardAncestorsRecord;
 }
 
+declare interface StreamDomainIngestRecord {
+    server?: string;
+    enabled?: boolean;
+    input?: {
+        raw_format?: string;
+        video_format?: string;
+    };
+    encoding?: {
+        [preset: string]: Record<string, unknown>;
+    };
+    record?: {
+        hls_time?: number;
+        hls_list_size?: number;
+        mainPreset?: string | {
+            video: string;
+            audio: string;
+        };
+        proxyPreset?: string | {
+            video: string;
+            audio: string;
+        };
+        main?: Record<string, unknown>;
+        proxy?: Record<string, unknown>;
+    };
+    stream?: {
+        mainPreset?: {
+            video: string;
+            audio: string;
+        };
+        proxyPreset?: {
+            video: string;
+            audio: string;
+        };
+        main?: Record<string, unknown>;
+        proxy?: Record<string, unknown>;
+    };
+    subtitle?: {
+        driver?: string;
+        template?: string;
+    };
+    video?: string;
+    audio?: string;
+    channels?: number;
+    audioDelay?: number;
+    interlaced?: boolean;
+}
+
+declare interface StreamDomainIngestStatsRecord {
+    status?: "starting" | "recording" | "streaming" | "stopping" | "stopped" | "restarting" | "stalled" | "deleted" | "exited" | "not configured" | "initializing" | "error";
+    server?: string;
+    hostname?: string;
+    port?: number;
+    error?: string;
+}
+
+declare interface StreamDomainRecord {
+    input?: "webcam" | "screen" | "url" | "push" | `ingest:${string}` | "srt-listener" | "srt-caller";
+    url?: string;
+    enabled?: boolean;
+    endpoints?: {
+        enabled?: boolean;
+        url?: string;
+        asset?: string;
+    }[];
+}
+
+declare interface StreamDomainRecords {
+    ":stream": StreamDomainRecord;
+    ":stream.stats?": StreamDomainStatsRecord;
+    ":stream.ingest": StreamDomainIngestRecord;
+    ":stream.ingest.stats?": StreamDomainIngestStatsRecord;
+}
+
+declare interface StreamDomainStatsRecord {
+    status?: "stopped" | "broadcasting" | "error";
+    proxyStatus?: "stopped" | "broadcasting" | "error";
+    rtmpUrl?: string;
+    rtmpPublishUrl?: string;
+    endpoints?: {
+        rtmpUrl?: string;
+        status?: "broadcasting" | "failed" | "created" | "stopped" | "finished";
+    }[];
+    error?: string;
+}
+
 /** OBSERVABLE INTERFACES */
 declare interface Subscribable<T> {
     subscribe(observer: Partial<Observer<T>>): Unsubscribable;
@@ -3895,10 +4421,45 @@ declare interface TemplateDomainRecords {
 
 declare interface TemplateProperty {
     path?: string;
+    type?: string;
+    label?: string;
+    defaultValue?: string;
+    widget?: {
+        type: string;
+    };
+    properties?: object;
+    items?: {
+        properties?: Record<string, TemplatePropertySchema>;
+    };
+    render?: {
+        type: "image";
+        profile?: {
+            format?: string;
+            video?: {
+                width: number;
+                height: number;
+                fit: "cover";
+            };
+        };
+    };
+}
+
+declare interface TemplatePropertySchema {
+    path?: string;
+    type?: string;
+    label?: string;
+    defaultValue?: string;
+    widget?: {
+        type: string;
+    };
+    items?: TemplatePropertySchema;
+    properties?: Record<string, TemplatePropertySchema>;
 }
 
 declare interface TemplateRecord {
+    source?: string;
     controller?: string;
+    type?: string;
     mixin?: string[];
     properties?: Record<string, TemplateProperty>;
 }
@@ -4201,12 +4762,26 @@ declare interface UserNotificationUnassigned extends UserNotificationCommon {
     };
 }
 
-declare interface WidgetItem {
-    type: WidgetType;
+declare type WidgetLayout = string | WidgetLayoutDivider | WidgetLayoutItem | WidgetLayout[];
+
+declare interface WidgetLayoutDivider {
+    type: "divider";
+    title?: string;
+}
+
+declare interface WidgetLayoutItem {
+    property: string;
+    width?: string | number;
+    widget?: WidgetType | WidgetOptions;
+}
+
+declare interface WidgetOptions {
+    type?: WidgetType;
     readOnly?: boolean;
+    [key: string]: unknown;
 }
 
-declare type WidgetType = "default" | "assetTypes" | "assetTags" | "geopoint" | "poster" | "textarea" | "tags";
+declare type WidgetType = string;
 
 /**
  * A base64 encoded string representing a complete Yjs document state.