@nxtedition/types 23.0.32 → 23.0.34

package/dist/nxtpression.d.ts

@@ -0,0 +1,2407 @@
+/// <reference lib="esnext.asynciterable" />
+
+/**
+ All diff* functions should return a list of operations, often empty.
+
+ Each operation should be an object with two to four fields:
+ * `op`: the name of the operation; one of "add", "remove", "replace", "move",
+ "copy", or "test".
+ * `path`: a JSON pointer string
+ * `from`: a JSON pointer string
+ * `value`: a JSON value
+
+ The different operations have different arguments.
+ * "add": [`path`, `value`]
+ * "remove": [`path`]
+ * "replace": [`path`, `value`]
+ * "move": [`from`, `path`]
+ * "copy": [`from`, `path`]
+ * "test": [`path`, `value`]
+
+ Currently this only really differentiates between Arrays, Objects, and
+ Everything Else, which is pretty much just what JSON substantially
+ differentiates between.
+ */
+declare interface AddOperation {
+    op: 'add';
+    path: string;
+    value: any;
+}
+
+export declare const assertGuardNxtpressionFetch: AssertionGuard<NxtpressionFetch>;
+
+export declare const assertGuardNxtpressionNxt: AssertionGuard<NxtpressionNxt>;
+
+declare type AssertionGuard<T> = (input: unknown) => asserts input is T;
+
+export declare const assertNxtpressionFetch: (input: unknown) => NxtpressionFetch;
+
+export declare const assertNxtpressionNxt: (input: unknown) => NxtpressionNxt;
+
+export declare const assertStringifyNxtpressionFetch: (input: unknown) => string;
+
+export declare const assertStringifyNxtpressionNxt: (input: unknown) => string;
+
+declare interface AssetAssigneesProvidedRecord {
+    value?: string[];
+}
+
+declare interface AssetCommentsRecord {
+    /**
+     * IDs of comment assets associated with the asset.
+     */
+    value?: string[];
+}
+
+declare interface AssetCreatedProvidedRecord {
+    time?: string;
+    user?: string;
+    origin?: string;
+}
+
+declare interface AssetDomainControllersProvidedRecord {
+    value?: string[];
+}
+
+declare interface AssetDomainDeadlinesProvidedRecord {
+    value?: IsoTimestamp[];
+}
+
+declare interface AssetDomainDurationProvidedRecord {
+    value?: number;
+}
+
+declare interface AssetDomainEmbeddingProvidedRecord {
+    value?: string[];
+}
+
+declare interface AssetDomainIconProvidedRecord {
+    value?: string;
+}
+
+declare interface AssetDomainLocationsProvidedRecord {
+    value?: Array<{
+        lat: number;
+        lon: number;
+    }>;
+}
+
+declare interface AssetDomainMediaProvidedRecord {
+    [key: string]: unknown;
+}
+
+declare interface AssetDomainPresenceProvidedRecord {
+    value?: string[];
+}
+
+declare interface AssetDomainPublishedProvidedRecord {
+    [publishedRecordId: string]: IsoTimestamp;
+}
+
+declare interface AssetDomainPublishProvidedRecord {
+    value?: string[];
+}
+
+declare interface AssetDomainRecords {
+    ":asset.title?": AssetTitleProvidedRecord;
+    ":asset.types?": AssetTypesProvidedRecord;
+    ":asset.assignees?": AssetAssigneesProvidedRecord;
+    ":asset.refs?": AssetRefsProvidedRecord;
+    ":asset.tags?": AssetTagsProvidedRecord;
+    ":asset.fileRefs?": AssetFileRefsProvidedRecord;
+    ":asset.created?": AssetCreatedProvidedRecord;
+    ":asset.modified?": AssetModifiedProvidedRecord;
+    ":asset.status?": AssetDomainStatusProvidedRecord;
+    ":asset.icon?": AssetDomainIconProvidedRecord;
+    ":asset.deadlines?": AssetDomainDeadlinesProvidedRecord;
+    ":asset.publish?": AssetDomainPublishProvidedRecord;
+    ":asset.published?": AssetDomainPublishedProvidedRecord;
+    ":asset.duration?": AssetDomainDurationProvidedRecord;
+    ":asset.locations?": AssetDomainLocationsProvidedRecord;
+    ":asset.controllers?": AssetDomainControllersProvidedRecord;
+    ":asset.embedding?": AssetDomainEmbeddingProvidedRecord;
+    ":asset.media?": AssetDomainMediaProvidedRecord;
+    ":asset.presence?": AssetDomainPresenceProvidedRecord;
+    ":asset.comments?": AssetCommentsRecord;
+}
+
+declare interface AssetDomainStatusProvidedRecord {
+    messages: Array<{
+        id: string;
+        msg: string;
+        level: number;
+        code: string;
+        expose?: boolean | null;
+        index?: number | null;
+    }>;
+}
+
+declare interface AssetFileRefsProvidedRecord {
+    value?: string[];
+}
+
+declare interface AssetModifiedProvidedRecord {
+    time?: string;
+    user?: string;
+    users?: string[];
+}
+
+declare interface AssetPermission {
+    type: "asset";
+    method: string;
+    tags?: undefined;
+}
+
+declare interface AssetRecords {
+    "asset.assignees": {
+        value?: Nxtpression<string[], {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.clone": {
+        rules: CloneRule[];
+    };
+    "asset.deadlines": {
+        value?: Nxtpression<string, {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.duration": {
+        value?: Nxtpression<number, {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.embedding": {
+        value?: Nxtpression<string, {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.icon": {
+        value?: Nxtpression<string, {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.locations": {
+        value?: Nxtpression<Array<{
+            lat: number;
+            lon: number;
+        }>, {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.media": {
+        value?: Nxtpression<Record<string, unknown>, {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.tags": {
+        value?: Nxtpression<string[], {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.title": {
+        value?: Nxtpression<string, {
+            id: string;
+        }>;
+        dynamic?: Dynamic;
+    };
+    "asset.types": {
+        [type: string]: null | string | {
+            priority?: number;
+            label: string;
+            icon?: string;
+        };
+    };
+}
+
+declare interface AssetRef {
+    id: string;
+    key: string;
+    value: string;
+}
+
+declare interface AssetRefsProvidedRecord {
+    value?: AssetRef[];
+}
+
+declare interface AssetTagsProvidedRecord {
+    value?: string[];
+}
+
+declare interface AssetTitleProvidedRecord {
+    value?: string;
+}
+
+declare interface AssetTypesProvidedRecord {
+    value?: string[];
+}
+
+declare interface BundleDomainRecords {
+    [":bundle"]: BundleRecord;
+    [":bundle.revisions"]: BundleRevisionsRecord;
+}
+
+declare interface BundleRecord {
+    user?: string;
+    description?: string;
+    files: Record<string, string>;
+}
+
+declare interface BundleRevisionsRecord {
+    [revisionId: string]: BundleRecord;
+}
+
+declare interface CloneDomainCloneRecord {
+    rules: CloneRule[];
+}
+
+declare interface CloneDomainRecords {
+    ":clone": CloneDomainCloneRecord;
+}
+
+declare interface CloneRule {
+    domain: string;
+    path?: string | null;
+    template?: string | null;
+}
+
+declare interface CommentDomainCommentRecord {
+    asset?: string;
+    content?: SerializedRootNode | null;
+    mediaRevisionId?: string | null;
+    timecode?: {
+        start: number;
+        end?: number;
+    };
+    replyTo?: string;
+}
+
+declare interface CommentDomainReadMarksProvidedRecord {
+    value?: string[];
+}
+
+declare interface CommentDomainRecords {
+    ":comment": CommentDomainCommentRecord;
+    ":comment.reactions?": CommentReactionsProvidedRecord;
+    ":comment.replies?": CommentDomainRepliesProvidedRecord;
+    ":comment.readMarks?": CommentDomainReadMarksProvidedRecord;
+}
+
+declare interface CommentDomainRepliesProvidedRecord {
+    value?: string[];
+}
+
+declare interface CommentReactionDomainRecord {
+    comment: string;
+    user: string;
+    reaction: string;
+}
+
+declare interface CommentReactionDomainRecords {
+    "comment-reaction": CommentReactionDomainRecord;
+}
+
+declare interface CommentReactionsProvidedRecord {
+    [reaction: string]: Array<{
+        id: string;
+        user: string;
+    }>;
+}
+
+declare interface CommentReadMarkDomainRecord {
+    comment: string;
+    user: string;
+    time: string;
+}
+
+declare interface CommentReadMarkDomainRecords {
+    "comment-read-mark": CommentReadMarkDomainRecord;
+}
+
+declare interface ConnectionDomainRecords {
+    [":connection"]: ConnectionRecord;
+    [":connection.methods?"]: Record<string, object>;
+    [":connection.stats?"]: ConnectionStatsRecord;
+}
+
+declare type ConnectionRecord = FilePublishConnectionRecord | ReutersConnectionRecord | FacebookConnectionRecord;
+
+declare interface ConnectionRecordCommon {
+    type: string;
+    userNotificationsEnabled?: boolean;
+}
+
+declare interface ConnectionStatsRecord {
+    status?: string;
+    substatus?: string;
+    pages?: Array<{
+        id: unknown;
+    }>;
+}
+
+declare interface ContactDomainRecords {
+    ":contact": ContactRecord;
+}
+
+declare interface ContactRecord {
+    title?: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+}
+
+declare interface CopyOperation {
+    op: 'copy';
+    from: string;
+    path: string;
+}
+
+declare interface DeepstreamDomainRecords {
+    ":deepstream.replicate": DeepstreamDomainReplicateRecord;
+}
+
+declare interface DeepstreamDomainReplicateRecord {
+    synced?: boolean;
+    since?: string | 0 | null;
+}
+
+declare interface DesignDomainRecord<Id = string, Key = string, Value = unknown> {
+    rows: DesignViewRow<Id, Key, Value>[];
+}
+
+declare interface DesignDomainRecords {
+    ":design": DesignDomainRecord;
+}
+
+declare interface DesignViewRow<Id = string, Key = string, Value = void> {
+    id: Id;
+    key: Key;
+    value: Value;
+}
+
+declare type DomainRecords = AssetDomainRecords & BundleDomainRecords & CloneDomainRecords & CommentReactionDomainRecords & CommentReadMarkDomainRecords & CommentDomainRecords & ConnectionDomainRecords & ContactDomainRecords & DeepstreamDomainRecords & DesignDomainRecords & EditDomainRecords & EventDomainRecords & FileDomainRecords & GeneralDomainRecords & MediaDomainRecords & PanelDomainRecords & PermissionDomainRecords & PipelinePresetDomainRecords & PipelineDomainRecords & PlanningDomainRecords & PublishDomainRecords & PublishedDomainRecords & RenderPresetDomainRecords & RenderDomainRecords & RevsDomainRecords & RoleDomainRecords & ScriptDomainRecords & SearchDomainRecords & SettingsDomainRecords & StoryboardDomainRecords & SubtitleStyleDomainRecords & SubtitleDomainRecords & TemplateDomainRecords & UserNotificationStatusDomainRecords & UserNotificationDomainRecords & UserDomainRecords;
+
+declare interface DomainRows {
+    rows: string[];
+}
+
+declare type Domains = Exclude<keyof DomainRecords, ":design">;
+
+declare type Dynamic = false | string[];
+
+declare interface EditDomainRecords {
+    ":edit": EditRecord;
+}
+
+declare interface EditRecord {
+    nodes: object;
+    tracks: object[];
+    transitions: object;
+    active?: boolean;
+    changeId?: string;
+}
+
+declare interface EventDomainRecords {
+    ":event": EventRecord;
+    ":event._template?": Record<string, unknown>;
+}
+
+declare interface EventRecord {
+    start?: number;
+    end?: number;
+    duration?: number;
+    text?: string;
+    lang?: string;
+    style?: string;
+    styleOverrides?: SubtitleEventStyleOverrides;
+}
+
+declare interface FacebookConnectionRecord extends ConnectionRecordCommon {
+    type: "facebook";
+    grantedScopes?: string[];
+}
+
+declare interface FacebookPublishRecord extends PublishRecordCommon<"facebook"> {
+    pageId?: string;
+}
+
+declare interface FacebookPublishStatsRecord extends PublishStatsRecordCommon {
+}
+
+declare interface File_2 {
+    id: string & Pattern<'^[0-9A-Za-z~][0-9A-Za-z~._: -]*$'>;
+    size: (number & Minimum<0> & Type<'uint64'>) | null;
+    seekable: boolean;
+    deleted: boolean;
+    refs: FileRefs;
+    tags: string[];
+    resumable: string;
+    mimeType: string;
+    encoding: string;
+    hash: string & Pattern<'^([A-Fa-f0-9]{32})?$'>;
+    btime: number & Minimum<0> & Type<'uint64'>;
+    completed: boolean;
+    error: NxtError[] | NxtError | null;
+}
+
+declare interface FileDomainRecords {
+    ":file.replicate": FileReplicateRecord;
+    ":file.restrictions": FileRestrictionsRecord;
+    ":file.stats?": FileDomainStatsRecord;
+}
+
+declare type FileDomainStatsRecord = FileStats;
+
+declare interface FilePublishBaseConnectionRecord extends ConnectionRecordCommon {
+    type: "file";
+    protocol: string;
+    host?: string;
+    port?: number | string;
+    ignoreMissing?: boolean;
+    concurrency?: number;
+    stabilityThreshold?: number;
+    pollInterval?: number;
+    listConcurrency?: number;
+    metafile?: {
+        content: string;
+    };
+}
+
+declare type FilePublishConnectionRecord = FilePublishConnectionS3Record;
+
+declare interface FilePublishConnectionS3Record extends FilePublishBaseConnectionRecord {
+    protocol: "s3";
+    client?: unknown;
+    bucket?: string;
+}
+
+declare interface FilePublishDefaults extends Record<string, unknown> {
+    directory: string;
+    filename: string;
+    renders: Record<string, FilePublishRender>;
+}
+
+declare interface FilePublishDraft extends Record<string, unknown> {
+    directory?: string;
+    filename?: string;
+}
+
+declare interface FilePublishPublished extends Record<string, unknown> {
+    directory?: string;
+    filename: string;
+}
+
+declare interface FilePublishRecord extends PublishRecordCommon<"file"> {
+    directory?: string;
+    filename?: string;
+    renders?: Record<string, FilePublishRender>;
+    draft?: FilePublishDraft;
+    remote?: FilePublishRemote;
+    published?: FilePublishPublished;
+}
+
+declare interface FilePublishRecordLegacy extends PublishRecordCommon<"file"> {
+    directory?: string;
+    filename?: string;
+    draft?: FilePublishDraft;
+    remote?: FilePublishRemoteLegacy;
+    published?: FilePublishPublished;
+    renders?: undefined;
+}
+
+declare interface FilePublishRemote extends Record<string, unknown> {
+    directory?: string;
+    filename?: string;
+    renders?: Record<string, FilePublishRemoteRender>;
+}
+
+declare interface FilePublishRemoteLegacy extends Record<string, unknown> {
+    id?: string;
+    path: string;
+    filename: string;
+    directory?: string;
+    subtitle?: {
+        path: string;
+    };
+    metafile?: {
+        path: string;
+    };
+}
+
+declare interface FilePublishRemoteRender {
+    path?: string;
+    messages?: Message[];
+    query?: unknown;
+    size?: number;
+    hash?: string;
+    source?: string;
+}
+
+declare type FilePublishRender = Nxtpression<ResolvedFilePublishRender, {
+    publish: FilePublishRecord;
+    directory: string;
+    name: string;
+}>;
+
+declare interface FilePublishRetrieved extends Record<string, unknown> {
+    filename?: string;
+    directory?: string;
+    renders?: Record<string, FilePublishRetrievedRender>;
+}
+
+declare interface FilePublishRetrievedRender {
+    path: string;
+    size?: number;
+    hash?: string;
+}
+
+declare interface FilePublishStatsRecord extends PublishStatsRecordCommon {
+    retrieved?: FilePublishRetrieved;
+    defaults?: FilePublishDefaults;
+}
+
+declare type FileRef = {
+    file?: string;
+    offset?: number;
+    start?: number;
+    end?: number;
+};
+
+declare type FileRefs = Array<FileRef>;
+
+declare interface FileReplicateRecord {
+    replicas: string[];
+    error: NxtError | null;
+}
+
+declare interface FileRestrictionsRecord {
+    [restrictionId: string]: {
+        asset: string;
+        date: string;
+        user: string;
+        text: string;
+        start: number;
+        end: number;
+    };
+}
+
+declare interface FileStats extends File_2 {
+    position: (number & Minimum<0> & Type<'uint64'>) | null;
+    uploading: boolean | null;
+    zones: string[];
+    replicas: string[];
+    locations: string[];
+    ranges: Array<[
+    start: number & Minimum<0>,
+    end: number & Minimum<0>
+    ]>;
+    progress?: number & Minimum<0> & Maximum<1>;
+    speed?: number & Minimum<0>;
+}
+
+declare interface GeneralCreatedRecord {
+    time?: string;
+    user?: string;
+    origin?: string;
+}
+
+declare interface GeneralDescriptionRecord {
+    value?: string;
+}
+
+declare interface GeneralDomainRecords {
+    ":general.title": GeneralTitleRecord;
+    ":general.tags": GeneralTagsRecord;
+    ":general.created": GeneralCreatedRecord;
+    ":general.poster": GeneralPosterRecord;
+    ":general.status": GeneralStatusRecord;
+    ":general.description": GeneralDescriptionRecord;
+}
+
+declare interface GeneralPosterRecord {
+    input?: {
+        type?: string;
+        file?: string;
+    };
+    preset?: string;
+}
+
+declare type GeneralStatusRecord = {
+    [messageId: string]: GeneralStatusRecordValue;
+};
+
+declare interface GeneralStatusRecordValue {
+    expose?: boolean;
+}
+
+/**
+ * Record holding manually added tags
+ */
+declare interface GeneralTagsRecord {
+    /**
+     * Manually added tags
+     */
+    value?: string[];
+}
+
+declare interface GeneralTitleRecord {
+    value?: string;
+}
+
+declare type Get<Data, Path extends string> = Path extends keyof Data ? Data[Path] : unknown;
+
+export declare const isNxtpressionFetch: (input: unknown) => input is NxtpressionFetch;
+
+export declare const isNxtpressionNxt: (input: unknown) => input is NxtpressionNxt;
+
+declare type IsoTimestamp = string;
+
+declare interface KeymapSetting {
+    title: string;
+    sequence?: string;
+}
+
+declare type LayoutWidget = WidgetType | WidgetItem;
+
+declare type Maximum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "maximum";
+    value: Value;
+    validate: `$input <= ${Numeric_2<Value>}`;
+    exclusive: ["maximum", "exclusiveMaximum"];
+    schema: Value extends number ? {
+        maximum: Value;
+    } : undefined;
+}>;
+
+declare interface MediaConsolidateRecord {
+    source?: unknown;
+    target?: unknown;
+    preset?: RenderPreset;
+    error?: unknown;
+}
+
+declare interface MediaDomainRecords {
+    ":media.source": MediaSourceRecord;
+    ":media.consolidate": MediaConsolidateRecord;
+    ":media.renders?": MediaRendersRecord;
+    ":media.transcriptChanges": MediaTranscriptChangesRecord;
+    ":media.font": MediaFontRecord;
+    ":media.restrictions?": MediaRestrictionsRecord;
+    ":media.probe?": MediaProbeRecord;
+    ":media.updateSubtitles?": Record<string, unknown>;
+    ":media.updateGraphics?": Record<string, unknown>;
+}
+
+declare interface MediaFontRecord {
+    sampleText?: string;
+}
+
+declare interface MediaProbeRecord {
+    duration?: number | null;
+    error: NxtError | null;
+    type: MediaType;
+    live?: boolean | null;
+    url?: string | null;
+    subtitle?: {
+        codec?: string | null;
+    };
+}
+
+declare interface MediaRenderRecordValue {
+    id?: string;
+    title?: string;
+    children?: MediaRenderRecordValue[];
+}
+
+declare interface MediaRendersRecord {
+    children: MediaRenderRecordValue[];
+}
+
+declare interface MediaRestrictionsRecord {
+    [restrictionId: string]: {
+        asset: string;
+        date: string;
+        user: string;
+        text: string;
+        start: number;
+        end: number;
+        file: string;
+    };
+}
+
+declare type MediaSourceRecord = RenderSceneObject;
+
+declare type MediaTranscriptChangesRecord = {
+    [patchKey: string]: MediaTranscriptChangesRecordValue;
+};
+
+declare interface MediaTranscriptChangesRecordValue {
+    patch?: Operation[];
+}
+
+declare type MediaType = "audio" | "video" | "image";
+
+declare interface Message {
+    level: number;
+    code: string;
+    msg: string;
+}
+
+declare type Minimum<Value extends number | bigint> = TagBase<{
+    target: Value extends number ? "number" : "bigint";
+    kind: "minimum";
+    value: Value;
+    validate: `${Numeric<Value>} <= $input`;
+    exclusive: ["minimum", "exclusiveMinimum"];
+    schema: Value extends number ? {
+        minimum: Value;
+    } : undefined;
+}>;
+
+declare interface ModuleTabs {
+    [tabId: string]: ModuleTabsSettingsValue;
+    settingsPanelStore: SettingsPanelStoreTab;
+}
+
+declare interface ModuleTabsSettingsValue {
+    activeTab: string;
+}
+
+declare interface MoveOperation {
+    op: 'move';
+    from: string;
+    path: string;
+}
+
+declare type NotificationReason = "mentioned" | "assigned" | "author" | "participated" | "always";
+
+declare type Numeric<Value extends number | bigint> = Value extends number ? Value : `BigInt(${Value})`;
+
+declare type Numeric_2<Value extends number | bigint> = Value extends number ? Value : `BigInt(${Value})`;
+
+declare interface NxtError {
+    message: string;
+    type?: string;
+    code?: string;
+    exitCode?: number;
+    signalCode?: number;
+    statusCode?: number;
+    headers?: Record<string, string>;
+    data?: object;
+    cause?: NxtError | null;
+    errors?: NxtError[] | null;
+}
+
+declare type Nxtpression<ReturnValue = string, Context extends object = object> = (String & {
+    /**
+     * 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.
+     */
+    __context: Context;
+    /**
+     * 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.
+     */
+    __returnValue: ReturnValue;
+}) | string | ReturnValue;
+
+export declare interface NxtpressionFetch {
+    body: string | null;
+    status: number | null;
+    headers: Record<string, string>;
+    err: any;
+}
+
+export declare interface NxtpressionNxt {
+    /**
+     * HTTP fetch
+     */
+    fetch(url: string, options?: RequestInit, suspend?: boolean): NxtpressionFetch;
+    observe<Value>(observable: Observable<Value>, suspend?: boolean): Value;
+    then<Value>(promise: Promise<Value>, suspend?: boolean): Value;
+    suspend(): void;
+    /**
+     * Creates a function which returns the input assetId, only if the asset is of the provided type.
+     * @param type Asset type to filter on, e.g. "general" or "media"
+     */
+    asset: (assetId: string, type: string, state?: number, suspend?: boolean) => (assetId: string) => string | null;
+    /**
+     * @deprecated
+     */
+    ds<Name extends keyof Records, Data extends Records[Name] & string>(name: Name, state?: RecordState, suspend?: boolean): Data;
+    /**
+     * Get a record.
+     */
+    get<Name extends keyof Records, Data extends Records[Name] = Records[Name], Path extends Paths<Data> | undefined | null = undefined>(name: Name, path?: Path, state?: RecordState, suspend?: boolean): Path extends undefined | null ? Data : Path extends Paths<Data> ? Get<Data, Path> : unknown;
+    get<Name extends keyof Records, Data extends Records[Name] = Records[Name]>(name: Name): Partial<Data>;
+    /**
+     * TODO: what is this doing?
+     */
+    wrap: <V>(value: V, suspend?: boolean) => unknown;
+    timer<V>(dueTime: number, dueValue: V, suspend?: boolean): V;
+    hash(value: unknown): string;
+}
+
+/**
+ * A representation of any set of values over any amount of time. This is the most basic building block
+ * of RxJS.
+ *
+ * @class Observable<T>
+ */
+declare class Observable<T> implements Subscribable<T> {
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     */
+    source: Observable<any> | undefined;
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     */
+    operator: Operator<any, T> | undefined;
+    /**
+     * @constructor
+     * @param {Function} subscribe the function that is called when the Observable is
+     * initially subscribed to. This function is given a Subscriber, to which new values
+     * can be `next`ed, or an `error` method can be called to raise an error, or
+     * `complete` can be called to notify of a successful completion.
+     */
+    constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
+    /**
+     * Creates a new Observable by calling the Observable constructor
+     * @owner Observable
+     * @method create
+     * @param {Function} subscribe? the subscriber function to be passed to the Observable constructor
+     * @return {Observable} a new observable
+     * @nocollapse
+     * @deprecated Use `new Observable()` instead. Will be removed in v8.
+     */
+    static create: (...args: any[]) => any;
+    /**
+     * Creates a new Observable, with this Observable instance as the source, and the passed
+     * operator defined as the new observable's operator.
+     * @method lift
+     * @param operator the operator defining the operation to take on the observable
+     * @return a new observable with the Operator applied
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     * If you have implemented an operator using `lift`, it is recommended that you create an
+     * operator by simply returning `new Observable()` directly. See "Creating new operators from
+     * scratch" section here: https://rxjs.dev/guide/operators
+     */
+    lift<R>(operator?: Operator<T, R>): Observable<R>;
+    subscribe(observerOrNext?: Partial<Observer<T>> | ((value: T) => void)): Subscription;
+    /** @deprecated Instead of passing separate callback arguments, use an observer argument. Signatures taking separate callback arguments will be removed in v8. Details: https://rxjs.dev/deprecations/subscribe-arguments */
+    subscribe(next?: ((value: T) => void) | null, error?: ((error: any) => void) | null, complete?: (() => void) | null): Subscription;
+    /**
+     * Used as a NON-CANCELLABLE means of subscribing to an observable, for use with
+     * APIs that expect promises, like `async/await`. You cannot unsubscribe from this.
+     *
+     * **WARNING**: Only use this with observables you *know* will complete. If the source
+     * observable does not complete, you will end up with a promise that is hung up, and
+     * potentially all of the state of an async function hanging out in memory. To avoid
+     * this situation, look into adding something like {@link timeout}, {@link take},
+     * {@link takeWhile}, or {@link takeUntil} amongst others.
+     *
+     * #### Example
+     *
+     * ```ts
+     * import { interval, take } from 'rxjs';
+     *
+     * const source$ = interval(1000).pipe(take(4));
+     *
+     * async function getTotal() {
+     *   let total = 0;
+     *
+     *   await source$.forEach(value => {
+     *     total += value;
+     *     console.log('observable -> ' + value);
+     *   });
+     *
+     *   return total;
+     * }
+     *
+     * getTotal().then(
+     *   total => console.log('Total: ' + total)
+     * );
+     *
+     * // Expected:
+     * // 'observable -> 0'
+     * // 'observable -> 1'
+     * // 'observable -> 2'
+     * // 'observable -> 3'
+     * // 'Total: 6'
+     * ```
+     *
+     * @param next a handler for each value emitted by the observable
+     * @return a promise that either resolves on observable completion or
+     *  rejects with the handled error
+     */
+    forEach(next: (value: T) => void): Promise<void>;
+    /**
+     * @param next a handler for each value emitted by the observable
+     * @param promiseCtor a constructor function used to instantiate the Promise
+     * @return a promise that either resolves on observable completion or
+     *  rejects with the handled error
+     * @deprecated Passing a Promise constructor will no longer be available
+     * in upcoming versions of RxJS. This is because it adds weight to the library, for very
+     * little benefit. If you need this functionality, it is recommended that you either
+     * polyfill Promise, or you create an adapter to convert the returned native promise
+     * to whatever promise implementation you wanted. Will be removed in v8.
+     */
+    forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
+    pipe(): Observable<T>;
+    pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
+    pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
+    pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
+    pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
+    pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
+    pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
+    pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
+    pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
+    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
+    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<unknown>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(): Promise<T | undefined>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
+    /** @deprecated Replaced with {@link firstValueFrom} and {@link lastValueFrom}. Will be removed in v8. Details: https://rxjs.dev/deprecations/to-promise */
+    toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
+}
+
+/**
+ * An object interface that defines a set of callback functions a user can use to get
+ * notified of any set of {@link Observable}
+ * {@link guide/glossary-and-semantics#notification notification} events.
+ *
+ * For more info, please refer to {@link guide/observer this guide}.
+ */
+declare interface Observer<T> {
+    /**
+     * A callback function that gets called by the producer during the subscription when
+     * the producer "has" the `value`. It won't be called if `error` or `complete` callback
+     * functions have been called, nor after the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#next this guide}.
+     */
+    next: (value: T) => void;
+    /**
+     * A callback function that gets called by the producer if and when it encountered a
+     * problem of any kind. The errored value will be provided through the `err` parameter.
+     * This callback can't be called more than one time, it can't be called if the
+     * `complete` callback function have been called previously, nor it can't be called if
+     * the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#error this guide}.
+     */
+    error: (err: any) => void;
+    /**
+     * A callback function that gets called by the producer if and when it has no more
+     * values to provide (by calling `next` callback function). This means that no error
+     * has happened. This callback can't be called more than one time, it can't be called
+     * if the `error` callback function have been called previously, nor it can't be called
+     * if the consumer has unsubscribed.
+     *
+     * For more info, please refer to {@link guide/glossary-and-semantics#complete this guide}.
+     */
+    complete: () => void;
+}
+
+declare type Operation = AddOperation | RemoveOperation | ReplaceOperation | MoveOperation | CopyOperation | TestOperation;
+
+/***
+ * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+ */
+declare interface Operator<T, R> {
+    call(subscriber: Subscriber<R>, source: any): TeardownLogic;
+}
+
+declare interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {
+}
+
+declare interface PanelDomainPanelRecord {
+    title?: string;
+    supports?: string[] | string;
+    priority?: number;
+    editorPriority?: number;
+    properties?: {
+        [key: string]: PanelProperty;
+    };
+    layout?: {
+        panel?: PanelLayout;
+        editor?: PanelLayout;
+    };
+    filter?: Nxtpression;
+    expand?: Nxtpression;
+}
+
+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 {
+    /** 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<unknown>;
+    /** 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?: unknown[];
+}
+
+declare type Paths<Data> = keyof Data & string;
+
+declare type Pattern<Value extends string> = TagBase<{
+    target: "string";
+    kind: "pattern";
+    value: Value;
+    validate: `/${Value}/.test($input)`;
+    exclusive: ["format", "pattern"];
+    schema: {
+        pattern: Value;
+    };
+}>;
+
+declare interface PermissionDomainRecords {
+    ":permission?": ProvidedPermissionRecord;
+    ":permission": PermissionRecord;
+}
+
+declare type PermissionRecord = PermissionRecordPermisson;
+
+declare type PermissionRecordPermisson = TagPermission | AssetPermission | RpcPermission;
+
+declare interface PipelineDomainItemsRecord {
+    value?: string[];
+}
+
+declare interface PipelineDomainRecord {
+    dummy?: boolean;
+    assetType?: "pipeline" | "collection";
+    preset?: string;
+    color?: string;
+    tags?: string[];
+    type?: string;
+    bookmarkId?: string;
+    hiddenCreateMenuItems?: Record<string, unknown>;
+}
+
+declare interface PipelineDomainRecords {
+    ":pipeline": PipelineDomainRecord;
+    ":pipeline.items": PipelineDomainItemsRecord;
+}
+
+declare interface PipelinePresetDomainRecord {
+    createMenuItems?: string[] | null;
+    color?: string;
+    tags?: string[];
+    sortMode?: PipelineSortMode;
+}
+
+declare interface PipelinePresetDomainRecords {
+    ":pipeline-preset": PipelinePresetDomainRecord;
+}
+
+declare type PipelineSortMode = "default" | "manual" | "az" | "za" | "newest" | "oldest" | "mostrecent" | "leastrecent" | "earliestdeadline" | "latestdeadline";
+
+declare interface PlanningAssigneesRecord {
+    value?: string[];
+}
+
+declare interface PlanningDeadlineRecord {
+    value: string | null;
+}
+
+declare interface PlanningDomainRecords {
+    ":planning": PlanningRecord;
+    ":planning.assignees": PlanningAssigneesRecord;
+    ":planning.deadline": PlanningDeadlineRecord;
+}
+
+declare interface PlanningRecord {
+    deadline?: string | null;
+}
+
+declare interface PromotedTag {
+    name: string | null;
+    icon: string | null;
+    color: string | null;
+    description: string | null;
+}
+
+declare interface ProvidedPermissionRecord {
+    permissions: PermissionRecordPermisson[];
+}
+
+declare interface PublishDomainAcceptsProvidedRecord {
+    value?: unknown;
+}
+
+declare interface PublishDomainRecords {
+    [":publish"]: PublishRecord;
+    [":publish.stats?"]: PublishStatsRecord;
+    [":publish.methods?"]: Record<string, {
+        rpcId: string;
+        rpcData: Record<string, unknown>;
+    }>;
+    [":publish.accepts"]: PublishDomainAcceptsProvidedRecord;
+}
+
+declare interface PublishedDomainRecords {
+    [":published"]: PublishedRecord;
+}
+
+declare interface PublishedRecord {
+    type: string;
+    parent: string;
+    asset: string[];
+    time: number;
+    connection: string;
+    user?: string;
+    error?: boolean;
+}
+
+declare type PublishRecord = YoutubePublishRecord | FacebookPublishRecord | FilePublishRecord | FilePublishRecordLegacy;
+
+declare interface PublishRecordCommon<Type extends PublishRecord["type"]> {
+    type: Type;
+    asset?: string;
+    connection?: string;
+    render?: PublishRender;
+    draft?: Record<string, unknown>;
+    published?: Record<string, unknown>;
+    remote?: Record<string, unknown>;
+    error?: {
+        method: string;
+    } | null;
+    messages?: Message[];
+}
+
+/**
+ * render preset + overrides
+ */
+declare interface PublishRender {
+    preset?: string;
+    type: string;
+    scene?: RenderSceneObject;
+    profile?: RenderProfileObject;
+}
+
+declare type PublishStatsRecord = YoutubePublishStatsRecord | FacebookPublishStatsRecord | FilePublishStatsRecord;
+
+declare interface PublishStatsRecordCommon {
+    status?: string;
+    substatus?: string;
+    messages?: Message[];
+    retrieved?: Record<string, unknown>;
+    defaults?: Record<string, unknown>;
+}
+
+export declare const randomNxtpressionFetch: () => NxtpressionFetch;
+
+export declare const randomNxtpressionNxt: () => {
+    fetch: never;
+    observe: never;
+    then: never;
+    suspend: never;
+    asset: never;
+    ds: never;
+    get: never;
+    wrap: never;
+    timer: never;
+    hash: never;
+};
+
+declare type Records = {
+    [Property in Domains as `${string}${Property}`]: DomainRecords[Property];
+} & {
+    ":permission": DomainRows;
+} & {
+    [Property in keyof DesignDomainRecords as `${string}${Property}${string}`]: DesignDomainRecords[Property];
+} & {
+    "media.subtitles": {
+        languages?: Record<string, string>;
+        fontFaces?: SubtitleFontFace[];
+    };
+    "media.subtitles?": {
+        languages?: Record<string, string>;
+        fontFaces?: SubtitleFontFace[];
+    };
+    "media.transcribe?": {
+        engines: Record<string, string>;
+        languages: Record<string, string>;
+        translate?: {
+            languages: Record<string, string>;
+        };
+    };
+    "media.consolidate": {
+        presets?: {
+            [type in MediaType]: RenderPreset;
+        };
+    };
+    "hub-transcribe:render-profile": {
+        format: string;
+        transcribe: {
+            engine: string;
+        };
+        pick: string[];
+    };
+} & AssetRecords & {
+    "asset-daemon": {
+        "user-notify"?: boolean;
+    };
+    "asset-daemon:user-notify.state": {
+        since?: string | 0 | null;
+        version?: number;
+    };
+    "deepstream-replicator.stats?": {
+        replicators?: Record<string, {
+            to: {
+                synced?: boolean;
+                since?: string | 0 | null;
+            };
+            from: {
+                since?: string | 0 | null;
+            };
+        }>;
+        synced?: boolean;
+    };
+};
+
+declare type RecordState = RecordStateNumber | RecordStateString;
+
+declare type RecordStateNumber = 0 | 1 | 2 | 3 | 4;
+
+declare type RecordStateString = "VOID" | "CLIENT" | "SERVER" | "STALE" | "PROVIDER";
+
+declare interface RemoveOperation {
+    op: 'remove';
+    path: string;
+}
+
+declare interface RenderDomainQueryRecord {
+    type: string;
+    title: string;
+    parent?: string;
+    description: {
+        scene: RenderSceneObject;
+        profile: RenderProfileObject;
+    };
+}
+
+declare interface RenderDomainRecords {
+    ":render.stats?": RenderDomainStatsRecord;
+    ":render.query?": RenderDomainQueryRecord;
+    ":render.result?": RenderDomainResultRecord;
+}
+
+declare interface RenderDomainResultRecord {
+    [key: string]: unknown;
+    url?: string;
+    result?: unknown;
+    error?: null | Record<string, unknown> | Array<Record<string, unknown>>;
+}
+
+declare interface RenderDomainStatsRecord {
+    progress?: number | null;
+    error?: Array<Record<string, unknown>> | null;
+    status?: string | null;
+}
+
+declare type RenderPreset = RenderPresetObject | string;
+
+declare interface RenderPresetDomainRecords {
+    ":render-preset": RenderPresetObject;
+}
+
+declare interface RenderPresetObject {
+    type: RenderQuery["type"];
+    profile: RenderProfile;
+}
+
+declare type RenderProfile = (RenderProfileObject | string) | (RenderProfileObject | string)[];
+
+declare interface RenderProfileObject {
+    format: string;
+    transcribe?: {
+        engine: string;
+    };
+    translate?: {
+        language: string;
+    };
+    audio?: {
+        pan?: string;
+    };
+    video?: unknown;
+    pick?: string[];
+    subtitle?: SubtitleProfile | SubtitleProfile["lang"];
+}
+
+declare interface RenderQuery {
+    type: string;
+    title: string;
+    parent?: string;
+    description?: {
+        scene?: RenderScene;
+        profile?: RenderProfile;
+    };
+}
+
+declare type RenderScene = (RenderSceneObject | string) | (RenderSceneObject | string)[];
+
+declare interface RenderSceneObject {
+    id?: string;
+    preset?: string;
+    input?: {
+        type?: string;
+        file?: string | null;
+    };
+    lang?: string;
+    subtitle?: string;
+    subtitleTracks?: {
+        [trackId: string]: {
+            style?: string | null;
+            styleOverrides?: Omit<SubtitleStyleDomainRecord, "scaledBorderAndShadow" | "futureWordWrapping">;
+        };
+    };
+    video?: {
+        crop?: {
+            x?: number;
+            y?: number;
+            width?: number;
+            height?: number;
+        };
+    };
+    start?: number;
+    end?: number;
+    transcribe?: {
+        language?: string;
+        pan?: number[];
+    };
+}
+
+declare interface ReplaceOperation {
+    op: 'replace';
+    path: string;
+    value: any;
+}
+
+declare interface ResolvedFilePublishRender extends Omit<PublishRender, "preset"> {
+    preset?: string;
+    name?: string;
+    path: string;
+    collisionStrategy?: "overwrite" | "skip";
+    ignoreEmptyScene?: boolean;
+}
+
+declare interface ReutersConnectionRecord extends ConnectionRecordCommon {
+    type: "reuters";
+    clientId?: string;
+    clientSecret?: string;
+    audience?: string;
+}
+
+declare interface RevsDomainRecords {
+    ":revs?": RevsRecord;
+}
+
+declare interface RevsRecord {
+    value?: string[];
+}
+
+declare interface RoleDomainRecords {
+    ":role.tags": RoleTagsRecord;
+}
+
+declare interface RoleTagsRecord {
+    value: string[];
+}
+
+declare interface RpcPermission {
+    type: "rpc";
+    method: string;
+    tags?: undefined;
+}
+
+declare interface ScriptChildrenRecord {
+    value?: string[];
+}
+
+declare interface ScriptDomainRecords {
+    ":script.children": ScriptChildrenRecord;
+}
+
+declare interface SearchDomainRecords {
+    ":search": SearchRecord;
+}
+
+declare interface SearchRecord {
+    hits: string[];
+    total?: number;
+    relation?: string;
+    error?: string;
+}
+
+declare interface SerializedAutoLinkNode {
+    type: "autolink";
+    version: 1;
+    url: string;
+}
+
+declare interface SerializedEmojiNode {
+    type: "emoji";
+    version: 1;
+    emojiId: string;
+}
+
+declare interface SerializedLineBreakNode {
+    type: "linebreak";
+    version: 1;
+}
+
+declare interface SerializedMentionNode {
+    type: "mention";
+    version: 1;
+    detail: number;
+    format: number;
+    mode: string;
+    style: string;
+    text: string;
+    mentionId: string;
+}
+
+declare type SerializedNode = SerializedRootNode | SerializedParagraphNode | SerializedTextNode | SerializedLineBreakNode | SerializedMentionNode | SerializedEmojiNode | SerializedAutoLinkNode;
+
+declare interface SerializedParagraphNode {
+    type: "paragraph";
+    version: 1;
+    direction: "ltr" | "rtl" | null;
+    format: string;
+    indent: number;
+    textFormat: number;
+    textStyle: string;
+    children: SerializedNode[];
+}
+
+declare interface SerializedRootNode {
+    type: "root";
+    version: 1;
+    direction: "ltr" | "rtl" | null;
+    format: string;
+    indent: number;
+    children: SerializedNode[];
+}
+
+declare interface SerializedTextNode {
+    type: "text";
+    version: 1;
+    detail: number;
+    format: number;
+    mode: string;
+    style: string;
+    text: string;
+}
+
+declare interface Settings {
+    autoLogoutTime?: number;
+    permission?: {
+        overrideUserContact: boolean;
+        overrideUserLogin: boolean;
+    };
+    module?: {
+        tabs?: ModuleTabs;
+    };
+    upload?: {
+        defaultGrouping?: "" | "collection" | "stitch";
+        hideStoryboardCollection?: boolean;
+        displayUploadFilesDialog?: "never" | "ifMultipleFiles" | "always";
+    };
+    download?: {
+        displaySaveDialog?: boolean;
+        /**
+         * Whether to prompt the user for each individual file path,
+         * or just the directory.
+         */
+        batchDownloadDialogMode?: "file" | "directory";
+    };
+    browser?: {
+        map: {
+            clustering?: boolean;
+            zoom?: number;
+            center?: {
+                lat: number;
+                lon: number;
+            };
+        };
+        createMenu: {
+            sortOrder: string[];
+        };
+    };
+    toolbarTags?: {
+        exclude: string[];
+    };
+    /**
+     * Controls which tags cannot be used together. When a tag from the group is
+     * manually added to an asset, any other tag from the group will be removed.
+     */
+    exclusiveTagGroups?: string[][];
+    deadlines?: {
+        include: string[];
+        exclude?: string[];
+    };
+    assignees?: {
+        include: string[];
+        exclude?: string[];
+    };
+    comments?: {
+        include?: string[];
+        exclude?: string[];
+    };
+    clock?: {
+        enable: boolean;
+        show24Hours: boolean;
+        showAmPm: boolean;
+        showSeconds: boolean;
+        showDayOfWeek: boolean;
+        showDate: boolean;
+        format?: string;
+    };
+    swarm?: {
+        color?: string;
+        name?: string;
+    };
+    dashboard?: {
+        maxMru: number;
+        maxTabs: number;
+    };
+    script?: {
+        createMenu: {
+            showPreview: boolean;
+        };
+        colorTags: PromotedTag[];
+    };
+    events?: {
+        graphicBaseTemplate?: string;
+    };
+    rundown?: {
+        eventThumbnails: boolean;
+    };
+    gallery?: {
+        dimOnBlur: 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;
+        };
+    };
+    media?: {
+        defaultFrameRate: number;
+        placeholder?: string;
+        guide?: {
+            mask?: boolean;
+            actionSafe?: boolean;
+            titleSafe?: boolean;
+        };
+        stepManyFrames: number;
+        liveZoomDuration: number;
+        importTitleTemplate: string;
+        tile: {
+            preview: boolean | "play" | "seek" | "seekplay" | "disabled";
+            showRenderProgress: boolean;
+        };
+        timecodeReference: string;
+        maxSubclipDuration: number;
+        rewindStep: number;
+        forwardStep: number;
+        interlacedPlayback: string;
+        playbackRates: number[];
+        subtitles: {
+            spacing: number;
+            maxCharactersPerLine: number;
+            aspectRatios?: Array<{
+                /** aspect ratio in the form of "width:height" */
+                aspectRatio?: string;
+                style?: string;
+                maxCharactersPerLine?: number;
+            }>;
+        };
+        subtitleTemplateId?: string;
+        initialVolume: string;
+        guides: Array<{
+            label: string;
+            aspectRatio: string;
+        }>;
+        download: boolean;
+        editMode: {
+            enabled: boolean;
+            defaultEnterOption: "edit" | "createNew" | "none";
+            defaultExitOption: "update" | "leave" | "none";
+        };
+        transcribe?: {
+            subtitleDisclaimer?: {
+                isUserConfigurable?: boolean;
+                defaultValue?: {
+                    enabled?: false;
+                    text?: Array<{
+                        language: string;
+                        value: string;
+                    }>;
+                    offset?: number;
+                    duration?: number;
+                };
+            };
+        };
+        openCommand?: {
+            url?: string;
+            command?: string;
+            app?: string;
+            args?: string[];
+        } | string;
+    };
+    edit?: {
+        thumbnailView: "filmStrip" | "thumbnail" | "none";
+        voiceOver: {
+            inputDevice?: string;
+            inputGainDb: number;
+            backgroundReductionDb: number;
+            recordMode: "instant" | "punchAndRoll";
+            preRollDuration: number;
+        };
+    };
+    commands?: Array<{
+        title: string;
+        command?: string;
+        args?: string[];
+    }>;
+    predefinedTags?: string[];
+    storyboard?: {
+        folded?: {
+            auto?: boolean;
+        };
+        assets: {
+            story: {
+                excerpt: {
+                    maxLines: number;
+                    mode: string;
+                };
+            };
+            note?: {
+                maxHeight?: number;
+            };
+        };
+        pipeline: {
+            search: {
+                maxItemsDisplayed: number;
+            };
+            sortMode: PipelineSortMode;
+        };
+        item: {
+            maxHeight: number;
+        };
+    };
+    hiddenPreviews?: Array<{
+        id: string;
+        folded: boolean;
+    }>;
+    plugins?: {
+        adobe: {
+            useProxies: boolean;
+        };
+        rive?: {
+            template?: string;
+        };
+    };
+    crashScreen?: boolean;
+    debug?: boolean;
+    featurePreview?: {
+        collections?: boolean;
+        semanticSearch?: boolean;
+        ameRemoteRendering?: boolean;
+    };
+    flags?: {
+        utils: boolean;
+        history: boolean;
+        refs: boolean;
+        access: boolean;
+        files: boolean;
+        export: boolean;
+        json: boolean;
+        hlsjs: boolean;
+        resetRenders?: boolean;
+        resetReplicas?: boolean;
+        assetStatus?: boolean;
+        consolidateMedia?: boolean;
+        hideInAssetMenu?: boolean;
+        assetRoute?: boolean;
+        devWarnings?: boolean;
+    };
+    notifications?: {
+        events: {
+            comment: NotificationReason[];
+            assigned: NotificationReason[];
+            unassigned: NotificationReason[];
+            publishSucceeded: {
+                [connectionId: string]: NotificationReason[];
+            };
+        };
+    };
+    suppressDeleteAlert?: boolean;
+}
+
+declare interface SettingsDomainRecords {
+    ":settings": Settings;
+}
+
+declare interface SettingsPanelStoreTab extends ModuleTabsSettingsValue {
+    activeSectionIndex: number;
+}
+
+declare interface StoryboardDomainPipelinesRecord {
+    value?: string[];
+}
+
+declare interface StoryboardDomainRecords {
+    ":storyboard": Record<string, unknown>;
+    ":storyboard.pipelines": StoryboardDomainPipelinesRecord;
+}
+
+export declare const stringifyNxtpressionFetch: (input: NxtpressionFetch) => string;
+
+export declare const stringifyNxtpressionNxt: (input: NxtpressionNxt) => string;
+
+/** OBSERVABLE INTERFACES */
+declare interface Subscribable<T> {
+    subscribe(observer: Partial<Observer<T>>): Unsubscribable;
+}
+
+/**
+ * Implements the {@link Observer} interface and extends the
+ * {@link Subscription} class. While the {@link Observer} is the public API for
+ * consuming the values of an {@link Observable}, all Observers get converted to
+ * a Subscriber, in order to provide Subscription-like capabilities such as
+ * `unsubscribe`. Subscriber is a common type in RxJS, and crucial for
+ * implementing operators, but it is rarely used as a public API.
+ *
+ * @class Subscriber<T>
+ */
+declare class Subscriber<T> extends Subscription implements Observer<T> {
+    /**
+     * A static factory for a Subscriber, given a (potentially partial) definition
+     * of an Observer.
+     * @param next The `next` callback of an Observer.
+     * @param error The `error` callback of an
+     * Observer.
+     * @param complete The `complete` callback of an
+     * Observer.
+     * @return A Subscriber wrapping the (partially defined)
+     * Observer represented by the given arguments.
+     * @nocollapse
+     * @deprecated Do not use. Will be removed in v8. There is no replacement for this
+     * method, and there is no reason to be creating instances of `Subscriber` directly.
+     * If you have a specific use case, please file an issue.
+     */
+    static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    protected isStopped: boolean;
+    /** @deprecated Internal implementation detail, do not use directly. Will be made internal in v8. */
+    protected destination: Subscriber<any> | Observer<any>;
+    /**
+     * @deprecated Internal implementation detail, do not use directly. Will be made internal in v8.
+     * There is no reason to directly create an instance of Subscriber. This type is exported for typings reasons.
+     */
+    constructor(destination?: Subscriber<any> | Observer<any>);
+    /**
+     * The {@link Observer} callback to receive notifications of type `next` from
+     * the Observable, with a value. The Observable may call this method 0 or more
+     * times.
+     * @param {T} [value] The `next` value.
+     * @return {void}
+     */
+    next(value?: T): void;
+    /**
+     * The {@link Observer} callback to receive notifications of type `error` from
+     * the Observable, with an attached `Error`. Notifies the Observer that
+     * the Observable has experienced an error condition.
+     * @param {any} [err] The `error` exception.
+     * @return {void}
+     */
+    error(err?: any): void;
+    /**
+     * The {@link Observer} callback to receive a valueless notification of type
+     * `complete` from the Observable. Notifies the Observer that the Observable
+     * has finished sending push-based notifications.
+     * @return {void}
+     */
+    complete(): void;
+    unsubscribe(): void;
+    protected _next(value: T): void;
+    protected _error(err: any): void;
+    protected _complete(): void;
+}
+
+/**
+ * Represents a disposable resource, such as the execution of an Observable. A
+ * Subscription has one important method, `unsubscribe`, that takes no argument
+ * and just disposes the resource held by the subscription.
+ *
+ * Additionally, subscriptions may be grouped together through the `add()`
+ * method, which will attach a child Subscription to the current Subscription.
+ * When a Subscription is unsubscribed, all its children (and its grandchildren)
+ * will be unsubscribed as well.
+ *
+ * @class Subscription
+ */
+declare class Subscription implements SubscriptionLike {
+    private initialTeardown?;
+    /** @nocollapse */
+    static EMPTY: Subscription;
+    /**
+     * A flag to indicate whether this Subscription has already been unsubscribed.
+     */
+    closed: boolean;
+    private _parentage;
+    /**
+     * The list of registered finalizers to execute upon unsubscription. Adding and removing from this
+     * list occurs in the {@link #add} and {@link #remove} methods.
+     */
+    private _finalizers;
+    /**
+     * @param initialTeardown A function executed first as part of the finalization
+     * process that is kicked off when {@link #unsubscribe} is called.
+     */
+    constructor(initialTeardown?: (() => void) | undefined);
+    /**
+     * Disposes the resources held by the subscription. May, for instance, cancel
+     * an ongoing Observable execution or cancel any other type of work that
+     * started when the Subscription was created.
+     * @return {void}
+     */
+    unsubscribe(): void;
+    /**
+     * Adds a finalizer to this subscription, so that finalization will be unsubscribed/called
+     * when this subscription is unsubscribed. If this subscription is already {@link #closed},
+     * because it has already been unsubscribed, then whatever finalizer is passed to it
+     * will automatically be executed (unless the finalizer itself is also a closed subscription).
+     *
+     * Closed Subscriptions cannot be added as finalizers to any subscription. Adding a closed
+     * subscription to a any subscription will result in no operation. (A noop).
+     *
+     * Adding a subscription to itself, or adding `null` or `undefined` will not perform any
+     * operation at all. (A noop).
+     *
+     * `Subscription` instances that are added to this instance will automatically remove themselves
+     * if they are unsubscribed. Functions and {@link Unsubscribable} objects that you wish to remove
+     * will need to be removed manually with {@link #remove}
+     *
+     * @param teardown The finalization logic to add to this subscription.
+     */
+    add(teardown: TeardownLogic): void;
+    /**
+     * Checks to see if a this subscription already has a particular parent.
+     * This will signal that this subscription has already been added to the parent in question.
+     * @param parent the parent to check for
+     */
+    private _hasParent;
+    /**
+     * Adds a parent to this subscription so it can be removed from the parent if it
+     * unsubscribes on it's own.
+     *
+     * NOTE: THIS ASSUMES THAT {@link _hasParent} HAS ALREADY BEEN CHECKED.
+     * @param parent The parent subscription to add
+     */
+    private _addParent;
+    /**
+     * Called on a child when it is removed via {@link #remove}.
+     * @param parent The parent to remove
+     */
+    private _removeParent;
+    /**
+     * Removes a finalizer from this subscription that was previously added with the {@link #add} method.
+     *
+     * Note that `Subscription` instances, when unsubscribed, will automatically remove themselves
+     * from every other `Subscription` they have been added to. This means that using the `remove` method
+     * is not a common thing and should be used thoughtfully.
+     *
+     * If you add the same finalizer instance of a function or an unsubscribable object to a `Subscription` instance
+     * more than once, you will need to call `remove` the same number of times to remove all instances.
+     *
+     * All finalizer instances are removed to free up memory upon unsubscription.
+     *
+     * @param teardown The finalizer to remove from this subscription
+     */
+    remove(teardown: Exclude<TeardownLogic, void>): void;
+}
+
+declare interface SubscriptionLike extends Unsubscribable {
+    unsubscribe(): void;
+    readonly closed: boolean;
+}
+
+declare interface SubtitleDomainRecord {
+    value?: Array<{
+        lang?: string;
+        start: number;
+        end: number;
+        text?: string;
+    }>;
+    style?: unknown;
+}
+
+declare interface SubtitleDomainRecords {
+    ":subtitle": SubtitleDomainRecord;
+}
+
+declare interface SubtitleEventStyleOverrides {
+    marginL?: string;
+    marginR?: string;
+    marginV?: string;
+    alignment?: string;
+    fontname?: string;
+    fontsize?: string;
+    primaryColour?: string;
+    secondaryColour?: string;
+    outlineColour?: string;
+    backColour?: string;
+    bold?: string;
+    italic?: string;
+    underline?: string;
+    strikeOut?: string;
+}
+
+declare interface SubtitleFontFace {
+    family: string;
+    asset?: string;
+    weight?: "normal" | "bold";
+    style?: "normal" | "italic";
+}
+
+declare interface SubtitleProfile {
+    /**
+     * Corresponds to a key in `media.subtitles?#languages`, or '_all' to render all languages.
+     */
+    lang?: string;
+    /**
+     * Will pick styling from the corresponding `${style}:subtitle-style` asset.
+     */
+    style?: string;
+}
+
+declare interface SubtitleStyleDomainRecord {
+    name?: string;
+    fontname?: string;
+    fontsize?: string;
+    primaryColour?: string;
+    secondaryColour?: string;
+    outlineColour?: string;
+    backColour?: string;
+    bold?: string;
+    italic?: string;
+    underline?: string;
+    strikeOut?: string;
+    scaleX?: string;
+    scaleY?: string;
+    spacing?: string;
+    angle?: string;
+    borderStyle?: string;
+    outline?: string;
+    shadow?: string;
+    alignment?: string;
+    marginL?: string;
+    marginR?: string;
+    marginV?: string;
+    encoding?: string;
+    scaledBorderAndShadow?: boolean;
+    futureWordWrapping?: boolean;
+}
+
+declare interface SubtitleStyleDomainRecords {
+    ":subtitle-style": SubtitleStyleDomainRecord;
+}
+
+declare type TagBase<Props extends TagBase.IProps<any, any, any, any, any, any>> = {
+    /**
+     * This is a dummy property for compilation.
+     *
+     * It does not mean anything in runtime.
+     */
+    "typia.tag"?: Props;
+};
+
+declare namespace TagBase {
+    interface IProps<Target extends "boolean" | "bigint" | "number" | "string" | "array", Kind extends string, Value extends boolean | bigint | number | string | undefined, Validate extends string | {
+        [key in Target]?: string;
+    }, Exclusive extends boolean | string[], Schema extends object | undefined> {
+        /**
+         * Target type.
+         *
+         * If user tries to adapt this tag to a different type, it would be a compile
+         * error.
+         *
+         * For example, you've configured target type as `string`, but user adapted it
+         * onto a `number` type (`number & YourCustomTag<Value>`), then it would be
+         * blocked by TypeScript compiler.
+         */
+        target: Target;
+        /**
+         * What kind of tag is this?
+         */
+        kind: Kind;
+        /**
+         * Value to be configured by user.
+         */
+        value: Value;
+        /**
+         * Validation script.
+         *
+         * This script would be inserted into the generated validation function.
+         * In here script, target variable name must be `$input`. The variable name
+         * `$input` would be transformed to the suitable when compilation.
+         *
+         * Also, If you've take a mistake on this script, compile error would be
+         * occured. So, define it with confidence. Compiler will block all your
+         * mistakes.
+         */
+        validate?: Validate;
+        /**
+         * Exclusive option.
+         *
+         * If this property configured as `true`, same {@link kind} tag cannot be
+         * duplicated in the target type. Otherwise, if you've configured this
+         * property as string array, all of the {@link kind} value assigned
+         * tags cannot be compatible in the target type.
+         *
+         * @default false
+         */
+        exclusive?: Exclusive | string[];
+        /**
+         * Additional schema info assigned to the {@link IJsonSchema} object.
+         */
+        schema?: Schema;
+    }
+}
+
+declare interface TagPermission {
+    type: "tag";
+    method?: undefined;
+    tags: string[];
+}
+
+declare type TeardownLogic = Subscription | Unsubscribable | (() => void) | void;
+
+declare interface TemplateDomainRecords {
+    ":template": TemplateRecord;
+}
+
+declare interface TemplateProperty {
+    path?: string;
+}
+
+declare interface TemplateRecord {
+    mixin?: string[];
+    properties?: Record<string, TemplateProperty>;
+}
+
+declare interface TestOperation {
+    op: 'test';
+    path: string;
+    value: any;
+}
+
+declare type Type<Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double"> = TagBase<{
+    target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
+    kind: "type";
+    value: Value;
+    validate: Value extends "int32" ? `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647` : Value extends "uint32" ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295` : Value extends "int64" ? {
+        number: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`;
+        bigint: `true`;
+    } : Value extends "uint64" ? {
+        number: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`;
+        bigint: `BigInt(0) <= $input`;
+    } : Value extends "float" ? `-1.175494351e38 <= $input && $input <= 3.4028235e38` : `true`;
+    exclusive: true;
+    schema: {
+        type: Value extends "int32" | "uint32" | "int64" | "uint64" ? "integer" : "number";
+    };
+}>;
+
+/**
+ * A function type interface that describes a function that accepts one parameter `T`
+ * and returns another parameter `R`.
+ *
+ * Usually used to describe {@link OperatorFunction} - it always takes a single
+ * parameter (the source Observable) and returns another Observable.
+ */
+declare interface UnaryFunction<T, R> {
+    (source: T): R;
+}
+
+declare type _UnaryFunction<T, U> = (arg: T extends null ? never : T) => U;
+
+export declare interface Underscore {
+    <T>(input: T): T;
+    <T, U>(input: T, fn1: _UnaryFunction<T, U>): U;
+    <T, U, V>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>): V;
+    <T, U, V, W>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>, fn3: _UnaryFunction<V, W>): W;
+    <T, U, V, W, X>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>, fn3: _UnaryFunction<V, W>, fn4: _UnaryFunction<W, X>): X;
+    <T, U, V, W, X, Y>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>, fn3: _UnaryFunction<V, W>, fn4: _UnaryFunction<W, X>, fn5: _UnaryFunction<X, Y>): Y;
+    <T, U, V, W, X, Y, Z>(input: T, fn1: _UnaryFunction<T, U>, fn2: _UnaryFunction<U, V>, fn3: _UnaryFunction<V, W>, fn4: _UnaryFunction<W, X>, fn5: _UnaryFunction<X, Y>, fn6: _UnaryFunction<Y, Z>): Z;
+    /**
+     * Creates a function which returns the input assetId, only if the asset is of the provided type.
+     * @param type Asset type to filter on, e.g. "general" or "media"
+     */
+    asset: (type: string, state?: number, suspend?: boolean) => (id: string) => string | null;
+    /**
+     * @deprecated
+     */
+    ds: <Postfix extends keyof DomainRecords, Data extends DomainRecords[Postfix] = DomainRecords[Postfix]>(postfix: Postfix, state?: number, suspend?: boolean) => (assetId: string) => Data;
+    /**
+     * Get a deepstream record
+     *
+     * Takes a postfix (typically a :domain) and optionally record path and/or
+     * desired state. Returns a function which takes a prefix (typically an asset
+     * ID).
+     *
+     * @example
+     * _.get(':contact') // (assetId: string) => ContactRecord
+     *
+     * @example
+     * _.get(':contact', null, 'server') // (assetId: string) => ContactRecord
+     *
+     * @example
+     * _.get(':contact', 'firstName') // (assetId: string) => string | undefined
+     *
+     * @example
+     * _.get(':contact', 'firstName', 'server') // (assetId: string) => string | undefined
+     */
+    get<Postfix extends keyof DomainRecords, Data extends DomainRecords[Postfix] = DomainRecords[Postfix], Path extends Paths<Data> | string | null | undefined = Paths<Data>>(postfix: Postfix, path: Path, state?: RecordState, suspend?: boolean): (assetId: string) => Path extends undefined | null ? Partial<Data> : Path extends Paths<Data> ? Get<Data, Path> | undefined : unknown;
+    get<Postfix extends keyof DomainRecords, Data extends DomainRecords[Postfix] = DomainRecords[Postfix]>(postfix: Postfix): (assetId: string) => Partial<Data>;
+    timer<V>(dueTime: number): (dueValue?: V) => V;
+    fetch(options?: RequestInit, suspend?: boolean): (resource: string) => NxtpressionFetch;
+}
+
+declare interface Unsubscribable {
+    unsubscribe(): void;
+}
+
+declare interface UserDomainLatestSeenNotificationRecord {
+    value?: string;
+}
+
+declare interface UserDomainReceivedNotificationsProvidedRecord {
+    /**
+     * IDs of notifications the user has received.
+     */
+    value?: string[];
+}
+
+declare interface UserDomainRecord {
+    username?: string;
+    roles?: string[];
+}
+
+declare interface UserDomainRecords {
+    ":user": UserDomainRecord;
+    ":user.latestSeenNotification": UserDomainLatestSeenNotificationRecord;
+    ":user.receivedNotifications?": UserDomainReceivedNotificationsProvidedRecord;
+    ":user.unseenNotifications?": UserDomainUnseenNotificationsRecord;
+}
+
+declare interface UserDomainUnseenNotificationsRecord {
+    hasUnseen?: boolean;
+    latestReceived?: string;
+}
+
+declare interface UserNotificationAddedToSearch extends UserNotificationCommon {
+    type: "added-to-search";
+    payload: {
+        searchId: string;
+        assetId: string;
+    };
+}
+
+declare interface UserNotificationAssigned extends UserNotificationCommon {
+    type: "assigned";
+    payload: {
+        assetId: string;
+        actionBy?: string;
+    };
+}
+
+declare interface UserNotificationComment extends UserNotificationCommon {
+    type: "comment";
+    payload: {
+        commentId: string;
+    };
+}
+
+declare interface UserNotificationCommon {
+    /** The user that the notification is for. */
+    userId: string;
+    /** The type of the notification, which will determine the shape of the payload. */
+    type: string;
+    /** Type specific data. */
+    payload: object;
+    /** When the notification was created. */
+    timestamp: string;
+    /** For what reasons the notification was created. */
+    reasons: NotificationReason[];
+    /**
+     * Asset that triggered this notification. Not necessarily the same asset that
+     * the notification is mainly about.
+     */
+    triggerId?: string;
+}
+
+declare interface UserNotificationDomainReadAtRecord {
+    /**
+     * ISO8601 date string. If set, the user has marked the notification as read at that timestamp.
+     */
+    value?: string;
+}
+
+declare interface UserNotificationDomainRecords {
+    ":user-notification": UserNotificationRecord;
+    ":user-notification.readAt": UserNotificationDomainReadAtRecord;
+}
+
+declare interface UserNotificationPublishSucceeded extends UserNotificationCommon {
+    type: "publishSucceeded";
+    payload: {
+        /** The user that published the asset. */
+        userId?: string;
+        /** The asset that was published. */
+        assetId: string;
+        /** The publish asset representing the publish. */
+        publishId: string;
+        /** The connection that was used to publish the asset. */
+        connectionId: string;
+    };
+}
+
+declare type UserNotificationRecord = UserNotificationAssigned | UserNotificationUnassigned | UserNotificationComment | UserNotificationAddedToSearch | UserNotificationPublishSucceeded;
+
+declare interface UserNotificationStatusAssignee {
+    /**
+     * Array of user ID:s that was assigned to the assed last time it was
+     * considered for notifications.
+     */
+    value?: string[];
+}
+
+declare interface UserNotificationStatusComment {
+    /**
+     * When array of user ID:s: Indicates which users have been considered for
+     * notifications about this comment. When `true`: Indicates that we have
+     * considered this comment for notifications, but we don't know which users
+     * have been notified.
+     */
+    value?: string[] | true;
+}
+
+declare interface UserNotificationStatusDomainRecord {
+    assignee?: UserNotificationStatusAssignee;
+    published?: UserNotificationStatusPublished;
+    comment?: UserNotificationStatusComment;
+}
+
+declare interface UserNotificationStatusDomainRecords {
+    ":_user-notification-status": UserNotificationStatusDomainRecord;
+}
+
+declare interface UserNotificationStatusPublished {
+    /**
+     * If `true`, this published asset has been considered for notifications.
+     */
+    value?: true;
+}
+
+declare interface UserNotificationUnassigned extends UserNotificationCommon {
+    type: "unassigned";
+    payload: {
+        assetId: string;
+        actionBy?: string;
+    };
+}
+
+declare interface WidgetItem {
+    type: WidgetType;
+    readOnly?: boolean;
+}
+
+declare type WidgetType = "default" | "assetTypes" | "assetTags" | "geopoint" | "poster" | "textarea" | "tags";
+
+declare interface YoutubePublishRecord extends PublishRecordCommon<"youtube"> {
+    draft?: {
+        snippet?: {
+            title?: string;
+            tags?: string[];
+            description?: string;
+        };
+    };
+}
+
+declare interface YoutubePublishStatsRecord extends PublishStatsRecordCommon {
+}
+
+export { }