commandbar 1.8.4 → 1.8.6

package/build/internal/src/middleware/commandCategory.d.ts

@@ -0,0 +1,192 @@
+/*******************************************************************************/
+import * as t from 'io-ts';
+import { GenericBatchRequest } from './generics';
+export declare const CommandCategoryV: t.IntersectionC<[t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    organization: t.UnionC<[t.NumberC, t.StringC]>;
+    name: t.StringC;
+}>, t.PartialC<{}>]>, t.TypeC<{
+    sort_key: t.UnionC<[t.NumberC, t.NullC]>;
+    icon: t.UnionC<[t.StringC, t.NullC]>;
+    icon_color: t.UnionC<[t.StringC, t.NullC]>;
+    image_color: t.UnionC<[t.StringC, t.NullC]>;
+    image: t.UnionC<[t.StringC, t.NullC]>;
+    render_as: t.UnionC<[t.LiteralC<"list">, t.LiteralC<"grid">]>;
+    setting_hide_before_search: t.BooleanC;
+    setting_max_options_count: t.UnionC<[t.NumberC, t.NullC]>;
+    setting_pin_to_bottom: t.BooleanC;
+    search_tab_enabled: t.BooleanC;
+    search_tab_name: t.StringC;
+    slash_filter_enabled: t.BooleanC;
+    slash_filter_keyword: t.UnionC<[t.StringC, t.NullC]>;
+    search_tab_instruction: t.StringC;
+    track_recents: t.BooleanC;
+}>, t.PartialC<{
+    contains_hotloaded_commands: t.BooleanC;
+}>]>;
+export declare const BatchEditorCategoryResponseV: t.TypeC<{
+    batch: t.ArrayC<t.IntersectionC<[t.IntersectionC<[t.TypeC<{
+        id: t.NumberC;
+        organization: t.UnionC<[t.NumberC, t.StringC]>;
+        name: t.StringC;
+    }>, t.PartialC<{}>]>, t.TypeC<{
+        sort_key: t.UnionC<[t.NumberC, t.NullC]>;
+        icon: t.UnionC<[t.StringC, t.NullC]>;
+        icon_color: t.UnionC<[t.StringC, t.NullC]>;
+        image_color: t.UnionC<[t.StringC, t.NullC]>;
+        image: t.UnionC<[t.StringC, t.NullC]>;
+        render_as: t.UnionC<[t.LiteralC<"list">, t.LiteralC<"grid">]>;
+        setting_hide_before_search: t.BooleanC;
+        setting_max_options_count: t.UnionC<[t.NumberC, t.NullC]>;
+        setting_pin_to_bottom: t.BooleanC;
+        search_tab_enabled: t.BooleanC;
+        search_tab_name: t.StringC;
+        slash_filter_enabled: t.BooleanC;
+        slash_filter_keyword: t.UnionC<[t.StringC, t.NullC]>;
+        search_tab_instruction: t.StringC;
+        track_recents: t.BooleanC;
+    }>, t.PartialC<{
+        contains_hotloaded_commands: t.BooleanC;
+    }>]>>;
+}>;
+export declare class CommandCategory {
+    static create: (object: {
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        icon_color: string | null;
+        image_color: string | null;
+        image: string | null;
+        render_as: "grid" | "list";
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        slash_filter_enabled: boolean;
+        slash_filter_keyword: string | null;
+        search_tab_instruction: string;
+        track_recents: boolean;
+    } & {
+        contains_hotloaded_commands?: boolean | undefined;
+    }, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        icon_color: string | null;
+        image_color: string | null;
+        image: string | null;
+        render_as: "grid" | "list";
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        slash_filter_enabled: boolean;
+        slash_filter_keyword: string | null;
+        search_tab_instruction: string;
+        track_recents: boolean;
+    } & {
+        contains_hotloaded_commands?: boolean | undefined;
+    }>;
+    static update: (object: {
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        icon_color: string | null;
+        image_color: string | null;
+        image: string | null;
+        render_as: "grid" | "list";
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        slash_filter_enabled: boolean;
+        slash_filter_keyword: string | null;
+        search_tab_instruction: string;
+        track_recents: boolean;
+    } & {
+        contains_hotloaded_commands?: boolean | undefined;
+    }, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        icon_color: string | null;
+        image_color: string | null;
+        image: string | null;
+        render_as: "grid" | "list";
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        slash_filter_enabled: boolean;
+        slash_filter_keyword: string | null;
+        search_tab_instruction: string;
+        track_recents: boolean;
+    } & {
+        contains_hotloaded_commands?: boolean | undefined;
+    }>;
+    static delete: (id: string | number, params?: Record<string, string> | undefined, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<void>;
+    static decode: (data: any) => {
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        icon_color: string | null;
+        image_color: string | null;
+        image: string | null;
+        render_as: "grid" | "list";
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        slash_filter_enabled: boolean;
+        slash_filter_keyword: string | null;
+        search_tab_instruction: string;
+        track_recents: boolean;
+    } & {
+        contains_hotloaded_commands?: boolean | undefined;
+    };
+    static batch: (request: t.TypeOf<typeof GenericBatchRequest>) => Promise<{
+        batch: ({
+            id: number;
+            organization: string | number;
+            name: string;
+        } & {} & {
+            sort_key: number | null;
+            icon: string | null;
+            icon_color: string | null;
+            image_color: string | null;
+            image: string | null;
+            render_as: "grid" | "list";
+            setting_hide_before_search: boolean;
+            setting_max_options_count: number | null;
+            setting_pin_to_bottom: boolean;
+            search_tab_enabled: boolean;
+            search_tab_name: string;
+            slash_filter_enabled: boolean;
+            slash_filter_keyword: string | null;
+            search_tab_instruction: string;
+            track_recents: boolean;
+        } & {
+            contains_hotloaded_commands?: boolean | undefined;
+        })[];
+    }>;
+}

package/build/internal/src/middleware/confetti.d.ts

@@ -0,0 +1,16 @@
+import * as t from 'io-ts';
+export declare const ConfettiConfigV: t.PartialC<{
+    angle: t.NumberC;
+    spread: t.NumberC;
+    width: t.StringC;
+    height: t.StringC;
+    duration: t.NumberC;
+    dragFriction: t.NumberC;
+    stagger: t.NumberC;
+    startVelocity: t.NumberC;
+    elementCount: t.NumberC;
+    decay: t.NumberC;
+    colors: t.ArrayC<t.StringC>;
+    random: t.AnyC;
+}>;
+export type IConfettiConfig = t.TypeOf<typeof ConfettiConfigV>;

package/build/internal/src/middleware/context.d.ts

@@ -0,0 +1,40 @@
+import * as t from 'io-ts';
+export declare const ContextV: t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    name: t.StringC;
+    organization: t.StringC;
+    value: t.RecordC<t.StringC, t.AnyC>;
+}>, t.PartialC<{}>]>;
+export declare class Context {
+    static create: (object: {
+        id: number;
+        name: string;
+        organization: string;
+        value: {
+            [x: string]: any;
+        };
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        name: string;
+        organization: string;
+        value: {
+            [x: string]: any;
+        };
+    } & {}>;
+    static update: (object: {
+        id: number;
+        name: string;
+        organization: string;
+        value: {
+            [x: string]: any;
+        };
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        name: string;
+        organization: string;
+        value: {
+            [x: string]: any;
+        };
+    } & {}>;
+    static delete: (id: string | number, params?: Record<string, string> | undefined, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<void>;
+}

package/build/internal/src/middleware/dashboardFlags.d.ts

@@ -0,0 +1,9 @@
+import * as t from 'io-ts';
+export declare const DashboardFlagsV: t.TypeC<{
+    show_onboarding: t.BooleanC;
+    show_appsumo_onboarding: t.BooleanC;
+}>;
+export declare const DashboardFlagsPartialV: t.PartialC<{
+    show_onboarding: t.BooleanC;
+    show_appsumo_onboarding: t.BooleanC;
+}>;

package/build/internal/src/middleware/detailPreview.d.ts

@@ -0,0 +1,24 @@
+/*******************************************************************************/
+import * as t from 'io-ts';
+import { IEditorCommandType } from './types';
+export declare const DetailPreviewObjectV: t.IntersectionC<[t.TypeC<{
+    type: t.UnionC<[t.LiteralC<"plaintext">, t.LiteralC<"markdown">, t.LiteralC<"html">, t.LiteralC<"react">, t.LiteralC<"video">, t.LiteralC<"component">]>;
+    value: t.StringC;
+}>, t.PartialC<{
+    position: t.UnionC<[t.LiteralC<"inline">, t.LiteralC<"popover">]>;
+}>]>;
+export type DetailPreviewObjectType = t.TypeOf<typeof DetailPreviewObjectV> & unknown;
+export type DetailPreviewType = string | DetailPreviewObjectType | (string | DetailPreviewObjectType)[];
+export type DataRowMetadata = {
+    type: 'command' | 'parameter';
+    label: string;
+    value: any;
+    contextKey?: string;
+    uid?: string;
+    inputText?: string;
+};
+export declare const DEFAULT_DETAIL_PREVIEW_TYPE: DetailPreviewObjectType['type'];
+export declare const standardize: (item: undefined | null | DetailPreviewType) => null | DetailPreviewObjectType[];
+export declare const getFirstDetail: (detail?: DetailPreviewType | null) => DetailPreviewObjectType | null;
+/** `true` iff the help document's body should also be used as the 'preview' for this command */
+export declare const shouldUseHelpDoc: (command: IEditorCommandType) => boolean;

package/build/internal/src/middleware/environment.d.ts

@@ -0,0 +1,11 @@
+import * as t from 'io-ts';
+export declare const EnvironmentV: t.TypeC<{
+    env: t.StringC;
+    version: t.UnionC<[t.NumberC, t.StringC, t.NullC, t.UndefinedC]>;
+}>;
+export declare class Environment {
+    static decode: (data: any) => {
+        env: string;
+        version: string | number | null | undefined;
+    };
+}

package/build/internal/src/middleware/generics.d.ts

@@ -0,0 +1,42 @@
+import * as t from 'io-ts';
+declare function decodeToPromise<T, O, I>(validator: t.Type<T, O, I>, input: I): Promise<T>;
+export declare function decodeToPromiseExact<T, O, I>(validator: t.Type<T, O, I> & t.HasProps, input: I): Promise<T>;
+declare function decodeThrowing<T, O, I>(validator: t.Type<T, O, I>, input: I): T;
+declare const GenericObject: t.TypeC<{
+    id: t.UnionC<[t.NumberC, t.StringC]>;
+}>;
+export type GenericObjectType = t.TypeOf<typeof GenericObject>;
+export declare const GenericBatchRequest: t.TypeC<{
+    batch: t.ArrayC<t.UnknownC>;
+    note: t.StringC;
+}>;
+declare function createObject<T, Q, O, I>(output: t.Type<T, O, I> & t.HasProps, input: t.Type<Q, O, I> & t.HasProps, url: string, params?: Record<string, string>): (object: Q, onSuccess?: () => void, onError?: (err: string) => void) => Promise<T>;
+declare function createObjectWithDecoder<T, Q, O, I>(decode: (result: any) => T, input: t.Type<Q, O, I> & t.HasProps, url: string, params?: Record<string, string>): (object: Q, onSuccess?: () => void, onError?: (err: string) => void) => Promise<T>;
+declare function readObject<T, O, I>(arg: t.Type<T, O, I> & t.HasProps, url: string): (arg0: string, params?: Record<string, string>, callbacks?: {
+    onSuccess?: () => void;
+    onError?: (err: string) => void;
+}) => Promise<T>;
+declare function listObject<T, O, I>(arg: t.Type<T, O, I> & t.HasProps, obj: string): (onSuccess?: () => void, onError?: (err: string) => void) => Promise<T[]>;
+declare function updateObject<T, O, I, Q extends GenericObjectType>(output: t.Type<T, O, I> & t.HasProps, input: t.Type<Q, O, I> & t.HasProps, url: string, params?: Record<string, string>): (object: Q, onSuccess?: () => void, onError?: (err: string) => void) => Promise<T>;
+declare function deleteObject<T, O, I>(arg: t.Type<T, O, I> & t.HasProps, url: string): (id: number | string, params?: Record<string, string>, onSuccess?: () => void, onError?: (err: string) => void) => Promise<void>;
+declare function readObjectDetail<T, O, I>(arg: t.Type<T, O, I> & t.HasProps, url: string, detail: string): (arg0: string, urlArgs?: {
+    [arg: string]: string;
+}, onSuccess?: () => void, onError?: (err: string) => void) => Promise<T>;
+declare function updateObjectDetail<T, O, I, J, K, Q extends GenericObjectType>(output: t.Type<T, O, I> & t.HasProps, input: t.Type<Q, K, J> & t.HasProps, url: string, detail: string): (object: Q, urlArgs?: {
+    [arg: string]: string;
+}, onSuccess?: () => void, onError?: (err: string) => void) => Promise<T>;
+declare function createObjectDetail<T, O, I, J, K, Q extends GenericObjectType>(output: t.Type<T, O, I> & t.HasProps, input: t.Type<Q, K, J> & t.HasProps, url: string, detail: string): (object: Q, onSuccess?: () => void, onError?: (err: string) => void, urlArgs?: {
+    [arg: string]: string;
+}) => Promise<T>;
+declare function loadIDList(ids: number[], klass: any, method?: string, urlArgs?: {
+    [arg: string]: string;
+}): Promise<any[]>;
+declare function read<T, O, I>(output: t.Type<T, O, I> & t.HasProps, url: string): (params?: Record<string, string>, callbacks?: {
+    onSuccess?: () => void;
+    onError?: (err: string) => void;
+}) => Promise<T>;
+declare function update<T, O, I, Q>(output: t.Type<T, O, I> & t.HasProps, input: t.Type<Q, O, I> & t.HasProps, url: string): (object: Q, params?: Record<string, string>, callbacks?: {
+    onSuccess?: () => void;
+    onError?: (err: string) => void;
+}) => Promise<T>;
+export { createObject, createObjectWithDecoder, createObjectDetail, read, readObject, listObject, update, updateObject, deleteObject, GenericObject, readObjectDetail, updateObjectDetail, loadIDList, decodeToPromise, decodeThrowing, };

package/build/internal/src/middleware/guide.d.ts

@@ -0,0 +1,37 @@
+import * as t from 'io-ts';
+export declare const GuideV: t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    organization: t.StringC;
+    event: t.StringC;
+    nudge: t.StringC;
+    guidance: t.StringC;
+}>, t.PartialC<{}>]>;
+export declare class Guide {
+    static create: (object: {
+        id: number;
+        organization: string;
+        event: string;
+        nudge: string;
+        guidance: string;
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string;
+        event: string;
+        nudge: string;
+        guidance: string;
+    } & {}>;
+    static update: (object: {
+        id: number;
+        organization: string;
+        event: string;
+        nudge: string;
+        guidance: string;
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string;
+        event: string;
+        nudge: string;
+        guidance: string;
+    } & {}>;
+    static delete: (id: string | number, params?: Record<string, string> | undefined, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<void>;
+}

package/build/internal/src/middleware/helpDocsIntegration.d.ts

@@ -0,0 +1,72 @@
+import * as t from 'io-ts';
+export declare const HelpDocsIntegrationV: t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    organization: t.StringC;
+    type: t.StringC;
+    schedule: t.StringC;
+    meta: t.UnionC<[t.RecordC<t.StringC, t.AnyC>, t.NullC]>;
+}>, t.PartialC<{}>]>;
+export declare class HelpDocsIntegration {
+    static create: (object: {
+        id: number;
+        organization: string;
+        type: string;
+        schedule: string;
+        meta: {
+            [x: string]: any;
+        } | null;
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string;
+        type: string;
+        schedule: string;
+        meta: {
+            [x: string]: any;
+        } | null;
+    } & {}>;
+    static read: (arg0: string, params?: Record<string, string> | undefined, callbacks?: {
+        onSuccess?: (() => void) | undefined;
+        onError?: ((err: string) => void) | undefined;
+    } | undefined) => Promise<{
+        id: number;
+        organization: string;
+        type: string;
+        schedule: string;
+        meta: {
+            [x: string]: any;
+        } | null;
+    } & {}>;
+    static list: (onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<({
+        id: number;
+        organization: string;
+        type: string;
+        schedule: string;
+        meta: {
+            [x: string]: any;
+        } | null;
+    } & {})[]>;
+    static update: (object: {
+        id: number;
+        organization: string;
+        type: string;
+        schedule: string;
+        meta: {
+            [x: string]: any;
+        } | null;
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string;
+        type: string;
+        schedule: string;
+        meta: {
+            [x: string]: any;
+        } | null;
+    } & {}>;
+    static delete: (id: string | number, params?: Record<string, string> | undefined, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<void>;
+    /** Get the status of the latest currently running sync for an integration */
+    static readSyncStatus: (integrationName: string) => Promise<{
+        running: boolean;
+        numFetched: number;
+        numProcessed: number;
+    }>;
+}

package/build/internal/src/middleware/helpDocsSync.d.ts

@@ -0,0 +1,63 @@
+import * as t from 'io-ts';
+export declare const HelpDocSyncLogMessageV: t.TypeC<{
+    ts: t.StringC;
+    type: t.StringC;
+    message: t.ArrayC<t.StringC>;
+}>;
+export declare const HelpDocsSyncV: t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    integration: t.NumberC;
+    scheduled: t.BooleanC;
+}>, t.PartialC<{
+    commands: t.ArrayC<t.NumberC>;
+    started: t.UnionC<[t.StringC, t.NullC]>;
+    ended: t.UnionC<[t.StringC, t.NullC]>;
+    log: t.ArrayC<t.UnionC<[t.ArrayC<t.AnyC>, t.TypeC<{
+        ts: t.StringC;
+        type: t.StringC;
+        message: t.ArrayC<t.StringC>;
+    }>]>>;
+}>]>;
+export declare class HelpDocsSync {
+    static create: (object: {
+        id: number;
+        integration: number;
+        scheduled: boolean;
+    } & {
+        commands?: number[] | undefined;
+        started?: string | null | undefined;
+        ended?: string | null | undefined;
+        log?: (any[] | {
+            ts: string;
+            type: string;
+            message: string[];
+        })[] | undefined;
+    }, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        integration: number;
+        scheduled: boolean;
+    } & {
+        commands?: number[] | undefined;
+        started?: string | null | undefined;
+        ended?: string | null | undefined;
+        log?: (any[] | {
+            ts: string;
+            type: string;
+            message: string[];
+        })[] | undefined;
+    }>;
+    static list: (onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<({
+        id: number;
+        integration: number;
+        scheduled: boolean;
+    } & {
+        commands?: number[] | undefined;
+        started?: string | null | undefined;
+        ended?: string | null | undefined;
+        log?: (any[] | {
+            ts: string;
+            type: string;
+            message: string[];
+        })[] | undefined;
+    })[]>;
+}