commandbar 1.6.13 → 1.6.16

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

@@ -8,6 +8,7 @@ export declare const CommandCategoryV: t.IntersectionC<[t.IntersectionC<[t.TypeC
 }>, t.PartialC<{}>]>, t.TypeC<{
     sort_key: t.UnionC<[t.NumberC, t.NullC]>;
     icon: 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]>;
@@ -27,6 +28,7 @@ export declare const BatchEditorCategoryResponseV: t.TypeC<{
     }>, t.PartialC<{}>]>, t.TypeC<{
         sort_key: t.UnionC<[t.NumberC, t.NullC]>;
         icon: 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]>;
@@ -47,6 +49,7 @@ export declare class CommandCategory {
     } & {} & {
         sort_key: number | null;
         icon: string | null;
+        image: string | null;
         render_as: "grid" | "list";
         setting_hide_before_search: boolean;
         setting_max_options_count: number | null;
@@ -64,6 +67,7 @@ export declare class CommandCategory {
     } & {} & {
         sort_key: number | null;
         icon: string | null;
+        image: string | null;
         render_as: "grid" | "list";
         setting_hide_before_search: boolean;
         setting_max_options_count: number | null;
@@ -82,6 +86,7 @@ export declare class CommandCategory {
     } & {} & {
         sort_key: number | null;
         icon: string | null;
+        image: string | null;
         render_as: "grid" | "list";
         setting_hide_before_search: boolean;
         setting_max_options_count: number | null;
@@ -99,6 +104,7 @@ export declare class CommandCategory {
     } & {} & {
         sort_key: number | null;
         icon: string | null;
+        image: string | null;
         render_as: "grid" | "list";
         setting_hide_before_search: boolean;
         setting_max_options_count: number | null;
@@ -118,6 +124,7 @@ export declare class CommandCategory {
     } & {} & {
         sort_key: number | null;
         icon: string | null;
+        image: string | null;
         render_as: "grid" | "list";
         setting_hide_before_search: boolean;
         setting_max_options_count: number | null;
@@ -137,6 +144,7 @@ export declare class CommandCategory {
         } & {} & {
             sort_key: number | null;
             icon: string | null;
+            image: string | null;
             render_as: "grid" | "list";
             setting_hide_before_search: boolean;
             setting_max_options_count: number | null;

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

@@ -1,14 +1,14 @@
 /*******************************************************************************/
 import * as t from 'io-ts';
 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.NullC]>;
+    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 declare type DetailPreviewObjectType = t.TypeOf<typeof DetailPreviewObjectV>;
 export declare type DetailPreviewType = string | DetailPreviewObjectType | (string | DetailPreviewObjectType)[];
-export declare type DataRowMedata = {
+export declare type DataRowMetadata = {
     type: 'command' | 'parameter';
     label: string;
     value: any;
@@ -17,7 +17,4 @@ export declare type DataRowMedata = {
 };
 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 | undefined) => DetailPreviewObjectType | {
-    type: null;
-    value: null;
-};
+export declare const getFirstDetail: (detail?: DetailPreviewType | null | undefined) => DetailPreviewObjectType | null;

package/build/internal/src/middleware/helpers/argument.d.ts

@@ -53,19 +53,21 @@ export declare const SetArgumentV: t.IntersectionC<[t.TypeC<{
     auto_choose: t.BooleanC;
     is_private: t.BooleanC;
 }>]>;
-export declare const VideoDashboardV: t.IntersectionC<[t.TypeC<{
+export declare const DashboardV: t.IntersectionC<[t.TypeC<{
     source: t.StringC;
 }>, t.PartialC<{
     title: t.StringC;
     description: t.StringC;
+    url: t.StringC;
 }>]>;
-export declare const VideoArgumentV: t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"video">;
+export declare const DashboardArgumentV: t.IntersectionC<[t.TypeC<{
+    type: t.UnionC<[t.LiteralC<"video">, t.LiteralC<"html">]>;
     value: t.IntersectionC<[t.TypeC<{
         source: t.StringC;
     }>, t.PartialC<{
         title: t.StringC;
         description: t.StringC;
+        url: t.StringC;
     }>]>;
     order_key: t.NumberC;
 }>, t.PartialC<{
@@ -262,12 +264,13 @@ export declare const ArgumentTypeV: t.UnionC<[t.IntersectionC<[t.TypeC<{
     auto_choose: t.BooleanC;
     is_private: t.BooleanC;
 }>]>, t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"video">;
+    type: t.UnionC<[t.LiteralC<"video">, t.LiteralC<"html">]>;
     value: t.IntersectionC<[t.TypeC<{
         source: t.StringC;
     }>, t.PartialC<{
         title: t.StringC;
         description: t.StringC;
+        url: t.StringC;
     }>]>;
     order_key: t.NumberC;
 }>, t.PartialC<{
@@ -397,12 +400,13 @@ export declare const ArgumentMapV: t.RecordC<t.StringC, t.UnionC<[t.Intersection
     auto_choose: t.BooleanC;
     is_private: t.BooleanC;
 }>]>, t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"video">;
+    type: t.UnionC<[t.LiteralC<"video">, t.LiteralC<"html">]>;
     value: t.IntersectionC<[t.TypeC<{
         source: t.StringC;
     }>, t.PartialC<{
         title: t.StringC;
         description: t.StringC;
+        url: t.StringC;
     }>]>;
     order_key: t.NumberC;
 }>, t.PartialC<{
@@ -535,12 +539,13 @@ export declare const StepArgumentTypeV: t.IntersectionC<[t.TypeC<{
     auto_choose: t.BooleanC;
     is_private: t.BooleanC;
 }>]>, t.IntersectionC<[t.TypeC<{
-    type: t.LiteralC<"video">;
+    type: t.UnionC<[t.LiteralC<"video">, t.LiteralC<"html">]>;
     value: t.IntersectionC<[t.TypeC<{
         source: t.StringC;
     }>, t.PartialC<{
         title: t.StringC;
         description: t.StringC;
+        url: t.StringC;
     }>]>;
     order_key: t.NumberC;
 }>, t.PartialC<{

package/build/internal/src/middleware/helpers/commandTemplate.d.ts

@@ -88,6 +88,15 @@ export declare const VideoTemplateV: t.IntersectionC<[t.TypeC<{
     hoverTooltip: t.BooleanC;
     operation: t.UnionC<[t.LiteralC<"router">, t.LiteralC<"self">, t.LiteralC<"blank">, t.UndefinedC]>;
 }>]>]>;
+export declare const HelpDocTemplateV: t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"helpdoc">;
+    value: t.StringC;
+}>, t.IntersectionC<[t.TypeC<{}>, t.PartialC<{
+    commandType: t.UnionC<[t.LiteralC<"independent">, t.LiteralC<"object">, t.LiteralC<"help">]>;
+    object: t.StringC;
+    hoverTooltip: t.BooleanC;
+    operation: t.UnionC<[t.LiteralC<"router">, t.LiteralC<"self">, t.LiteralC<"blank">, t.UndefinedC]>;
+}>]>]>;
 export declare const RequestV: t.IntersectionC<[t.TypeC<{
     method: t.UnionC<[t.LiteralC<"get">, t.LiteralC<"delete">, t.LiteralC<"head">, t.LiteralC<"options">, t.LiteralC<"post">, t.LiteralC<"put">, t.LiteralC<"patch">]>;
     url: t.StringC;
@@ -205,4 +214,12 @@ export declare const TemplateV: t.UnionC<[t.IntersectionC<[t.TypeC<{
     object: t.StringC;
     hoverTooltip: t.BooleanC;
     operation: t.UnionC<[t.LiteralC<"router">, t.LiteralC<"self">, t.LiteralC<"blank">, t.UndefinedC]>;
+}>]>]>, t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"helpdoc">;
+    value: t.StringC;
+}>, t.IntersectionC<[t.TypeC<{}>, t.PartialC<{
+    commandType: t.UnionC<[t.LiteralC<"independent">, t.LiteralC<"object">, t.LiteralC<"help">]>;
+    object: t.StringC;
+    hoverTooltip: t.BooleanC;
+    operation: t.UnionC<[t.LiteralC<"router">, t.LiteralC<"self">, t.LiteralC<"blank">, t.UndefinedC]>;
 }>]>]>]>;

package/build/internal/src/middleware/helpers/rules.d.ts

@@ -45,6 +45,34 @@ export declare const ConditionV: t.IntersectionC<[t.TypeC<{
     value: t.StringC;
     reason: t.StringC;
 }>]>;
+export declare const getConditions: (expr: RuleExpression) => ExpressionCondition[];
+export declare const canonicalize: (expr: RuleExpression) => RuleExpression;
+export declare function isCompoundExpression(expr: RuleExpression): expr is RuleExpressionAnd | RuleExpressionOr;
+export declare type ExpressionCondition = t.TypeOf<typeof ConditionV> | t.TypeOf<typeof NamedRuleReferenceV>;
+export declare type RuleExpression = RuleExpressionAnd | RuleExpressionOr | RuleExpressionLiteral | RuleExpressionCondition;
+export declare type RuleExpressionAnd = {
+    type: 'AND';
+    exprs: RuleExpression[];
+};
+export declare type RuleExpressionOr = {
+    type: 'OR';
+    exprs: RuleExpression[];
+};
+export declare type RuleExpressionLiteral = {
+    type: 'LITERAL';
+    value: boolean;
+};
+export declare type RuleExpressionCondition = {
+    type: 'CONDITION';
+    condition: ExpressionCondition;
+};
+export declare const RuleExpressionAndV: t.Type<RuleExpressionAnd>;
+export declare const RuleExpressionOrV: t.Type<RuleExpressionOr>;
+export declare const RuleExpressionLiteralV: t.Type<RuleExpressionLiteral>;
+export declare const RuleExpressionConditionV: t.Type<RuleExpressionCondition>;
+export declare const RuleExpressionV: t.Type<RuleExpression>;
+export declare const RuleExpressionTrue: t.TypeOf<typeof RuleExpressionLiteralV>;
+export declare const RuleExpressionFalse: t.TypeOf<typeof RuleExpressionLiteralV>;
 export declare const NamedRuleReferenceV: t.IntersectionC<[t.TypeC<{
     type: t.LiteralC<"named_rule">;
     rule_id: t.NumberC;
@@ -190,32 +218,7 @@ export declare const EditorRecommendationRuleV: t.UnionC<[t.UnionC<[t.Intersecti
 export declare const NamedRuleV: t.TypeC<{
     id: t.NumberC;
     name: t.StringC;
-    conditions: t.ArrayC<t.IntersectionC<[t.TypeC<{
-        type: t.UnionC<[t.LiteralC<"context">, t.LiteralC<"url">, t.LiteralC<"element">]>;
-        operator: t.KeyofC<{
-            includes: null;
-            endsWith: null;
-            startsWith: null;
-            is: null;
-            isTruthy: null;
-            isFalsy: null;
-            isNot: null;
-            isTrue: null;
-            isFalse: null;
-            doesNotInclude: null;
-            matchesRegex: null;
-            isGreaterThan: null;
-            isLessThan: null;
-            isDefined: null;
-            isNotDefined: null;
-            classnameOnPage: null;
-            idOnPage: null;
-        }>;
-    }>, t.PartialC<{
-        field: t.StringC;
-        value: t.StringC;
-        reason: t.StringC;
-    }>]>>;
+    expression: t.Type<RuleExpression, RuleExpression, unknown>;
 }>;
 export declare type IRuleOperator = t.TypeOf<typeof OperatorV>;
 export declare type IAvailabilityRule = t.TypeOf<typeof AvailabilityRuleV>;

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

@@ -0,0 +1,197 @@
+import * as t from 'io-ts';
+export declare const NudgeV: t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    organization: t.StringC;
+    slug: t.StringC;
+    content: t.StringC;
+    show_expression: t.Type<import("./helpers/rules").RuleExpression, import("./helpers/rules").RuleExpression, unknown>;
+    trigger: t.UnionC<[t.TypeC<{
+        type: t.LiteralC<"when_conditions_pass">;
+    }>, t.TypeC<{
+        type: t.LiteralC<"on_command_execution">;
+        meta: t.TypeC<{
+            command: t.StringC;
+        }>;
+    }>]>;
+    on_select: t.TypeC<{
+        type: t.LiteralC<"execute_command">;
+        meta: t.TypeC<{
+            command: t.StringC;
+        }>;
+    }>;
+    timeout_ms: t.UnionC<[t.NumberC, t.NullC]>;
+    frequency_limit: t.UnionC<[t.LiteralC<"no_limit">, t.LiteralC<"once_per_session">, t.LiteralC<"once_per_user">]>;
+    is_live: t.BooleanC;
+}>, t.PartialC<{}>]>;
+export declare class Nudge {
+    static decode: (data: any) => {
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+        is_live: boolean;
+    } & {};
+    static create: (object: {
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+        is_live: boolean;
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+        is_live: boolean;
+    } & {}>;
+    static update: (object: {
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+        is_live: boolean;
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+        is_live: boolean;
+    } & {}>;
+    static delete: (id: string | number, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<void>;
+    static list: (onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<({
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+        is_live: boolean;
+    } & {})[]>;
+    static read: (arg0: string, params?: Record<string, string> | undefined, callbacks?: {
+        onSuccess?: (() => void) | undefined;
+        onError?: ((err: string) => void) | undefined;
+    } | undefined) => Promise<{
+        id: number;
+        organization: string;
+        slug: string;
+        content: string;
+        show_expression: import("./helpers/rules").RuleExpression;
+        trigger: {
+            type: "when_conditions_pass";
+        } | {
+            type: "on_command_execution";
+            meta: {
+                command: string;
+            };
+        };
+        on_select: {
+            type: "execute_command";
+            meta: {
+                command: string;
+            };
+        };
+        timeout_ms: number | null;
+        frequency_limit: "no_limit" | "once_per_session" | "once_per_user";
+        is_live: boolean;
+    } & {}>;
+}