commandbar 1.6.4 → 1.6.5-alpha.1

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

@@ -0,0 +1,87 @@
+/*******************************************************************************/
+import * as t from 'io-ts';
+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]>;
+    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;
+    search_tab_instruction: t.StringC;
+}>]>;
+export declare class CommandCategory {
+    static create: (object: {
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        search_tab_instruction: string;
+    }, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        search_tab_instruction: string;
+    }>;
+    static update: (object: {
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        search_tab_instruction: string;
+    }, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<{
+        id: number;
+        organization: string | number;
+        name: string;
+    } & {} & {
+        sort_key: number | null;
+        icon: string | null;
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        search_tab_instruction: string;
+    }>;
+    static delete: (id: string | number, 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;
+        setting_hide_before_search: boolean;
+        setting_max_options_count: number | null;
+        setting_pin_to_bottom: boolean;
+        search_tab_enabled: boolean;
+        search_tab_name: string;
+        search_tab_instruction: string;
+    };
+}

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, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<void>;
+}

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,32 @@
+import * as t from 'io-ts';
+declare function decodeToPromise<T, O, I>(validator: t.Type<T, O, I>, 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 declare type GenericObjectType = t.TypeOf<typeof GenericObject>;
+declare function createObject<T, Q, O, I>(output: t.Type<T, O, I>, input: t.Type<Q, O, I>, 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>, 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>, 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>, input: t.Type<Q, O, I>, 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>, url: string, params?: Record<string, string>): (id: number | string, onSuccess?: () => void, onError?: (err: string) => void) => Promise<void>;
+declare function readObjectDetail<T, O, I>(arg: t.Type<T, O, I>, 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>, input: t.Type<Q, K, J>, 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>, input: t.Type<Q, K, J>, 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>(arg: t.Type<T, O, I>, url: string): (params?: Record<string, string>, callbacks?: {
+    onSuccess?: () => void;
+    onError?: (err: string) => void;
+}) => Promise<T>;
+export { createObject, createObjectDetail, read, readObject, listObject, 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, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<void>;
+}

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

@@ -0,0 +1,10 @@
+import * as t from 'io-ts';
+export declare const EndUserV: t.TypeC<{
+    username: t.StringC;
+    slug: t.StringC;
+    organization: t.StringC;
+    has_access: t.BooleanC;
+    has_opened: t.BooleanC;
+    hotkeys_debug: t.BooleanC;
+    hmac: t.UnionC<[t.StringC, t.UndefinedC]>;
+}>;

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

@@ -19,7 +19,7 @@ declare const OperatorV: t.KeyofC<{
     classnameOnPage: null;
     idOnPage: null;
 }>;
-export declare const AvailabilityRuleV: t.IntersectionC<[t.TypeC<{
+export declare const ConditionV: t.IntersectionC<[t.TypeC<{
     type: t.UnionC<[t.LiteralC<"context">, t.LiteralC<"url">, t.LiteralC<"element">]>;
     operator: t.KeyofC<{
         includes: null;
@@ -45,9 +45,22 @@ export declare const AvailabilityRuleV: t.IntersectionC<[t.TypeC<{
     value: t.StringC;
     reason: t.StringC;
 }>]>;
-export declare const RecommendationRuleV: t.IntersectionC<[t.TypeC<{
-    type: t.UnionC<[t.LiteralC<"context">, t.LiteralC<"url">, t.LiteralC<"element">, t.LiteralC<"always">]>;
+export declare const NamedRuleReferenceV: t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"named_rule">;
+    rule_id: t.NumberC;
+}>, t.PartialC<{
+    reason: t.StringC;
+}>]>;
+export declare const RecommendationRuleAlwaysV: t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"always">;
 }>, t.PartialC<{
+    operator: t.UnionC<[t.UndefinedC, t.NullC]>;
+    field: t.UnionC<[t.UndefinedC, t.NullC]>;
+    value: t.UnionC<[t.UndefinedC, t.NullC]>;
+    reason: t.UnionC<[t.UndefinedC, t.NullC]>;
+}>]>;
+export declare const AvailabilityRuleV: t.IntersectionC<[t.TypeC<{
+    type: t.UnionC<[t.LiteralC<"context">, t.LiteralC<"url">, t.LiteralC<"element">]>;
     operator: t.KeyofC<{
         includes: null;
         endsWith: null;
@@ -67,14 +80,152 @@ export declare const RecommendationRuleV: t.IntersectionC<[t.TypeC<{
         classnameOnPage: null;
         idOnPage: null;
     }>;
+}>, t.PartialC<{
     field: t.StringC;
     value: t.StringC;
     reason: t.StringC;
 }>]>;
+export declare const RecommendationRuleV: t.UnionC<[t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"always">;
+}>, t.PartialC<{
+    operator: t.UnionC<[t.UndefinedC, t.NullC]>;
+    field: t.UnionC<[t.UndefinedC, t.NullC]>;
+    value: t.UnionC<[t.UndefinedC, t.NullC]>;
+    reason: t.UnionC<[t.UndefinedC, t.NullC]>;
+}>]>, 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;
+}>]>]>;
+export declare const EditorAvailabilityRuleV: t.UnionC<[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;
+}>]>, t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"named_rule">;
+    rule_id: t.NumberC;
+}>, t.PartialC<{
+    reason: t.StringC;
+}>]>]>;
+export declare const EditorRecommendationRuleV: t.UnionC<[t.UnionC<[t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"always">;
+}>, t.PartialC<{
+    operator: t.UnionC<[t.UndefinedC, t.NullC]>;
+    field: t.UnionC<[t.UndefinedC, t.NullC]>;
+    value: t.UnionC<[t.UndefinedC, t.NullC]>;
+    reason: t.UnionC<[t.UndefinedC, t.NullC]>;
+}>]>, 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;
+}>]>]>, t.IntersectionC<[t.TypeC<{
+    type: t.LiteralC<"named_rule">;
+    rule_id: t.NumberC;
+}>, t.PartialC<{
+    reason: t.StringC;
+}>]>]>;
+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;
+    }>]>>;
+}>;
 export declare type IRuleOperator = t.TypeOf<typeof OperatorV>;
 export declare type IAvailabilityRule = t.TypeOf<typeof AvailabilityRuleV>;
+export declare type IEditorAvailabilityRule = t.TypeOf<typeof EditorAvailabilityRuleV>;
 export declare type IRecommendationRule = t.TypeOf<typeof RecommendationRuleV>;
+export declare type IEditorRecommendationRule = t.TypeOf<typeof EditorRecommendationRuleV>;
+export declare type ICondition = t.TypeOf<typeof ConditionV>;
 export declare type IAvailabilityRuleType = IAvailabilityRule['type'];
 export declare type IRecommendationRuleType = IRecommendationRule['type'];
 export declare type IRule = IAvailabilityRule | IRecommendationRule;
+export declare type IEditorRule = IEditorAvailabilityRule | IEditorRecommendationRule;
+export declare type INamedRule = t.TypeOf<typeof NamedRuleV>;
 export {};

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

@@ -0,0 +1,40 @@
+import * as t from 'io-ts';
+export declare const HistoryEventV: t.IntersectionC<[t.TypeC<{
+    id: t.NumberC;
+    organization: t.StringC;
+    changed_by: t.StringC;
+    description: t.StringC;
+    created: t.StringC;
+    sha1: t.StringC;
+    version_num: t.NumberC;
+}>, t.PartialC<{}>]>;
+export declare class HistoryEvent {
+    static list: (onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined) => Promise<({
+        id: number;
+        organization: string;
+        changed_by: string;
+        description: string;
+        created: string;
+        sha1: string;
+        version_num: number;
+    } & {})[]>;
+    static revert: (object: {
+        id: number;
+        organization: string;
+        changed_by: string;
+        description: string;
+        created: string;
+        sha1: string;
+        version_num: number;
+    } & {}, onSuccess?: (() => void) | undefined, onError?: ((err: string) => void) | undefined, urlArgs?: {
+        [arg: string]: string;
+    } | undefined) => Promise<{
+        id: number;
+        organization: string;
+        changed_by: string;
+        description: string;
+        created: string;
+        sha1: string;
+        version_num: number;
+    } & {}>;
+}

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

@@ -0,0 +1,4 @@
+export declare const baseURL: string;
+export declare const authorizationHeader: string | null;
+declare const axiosInstance: import("axios").AxiosInstance;
+export default axiosInstance;