@rancher/shell 3.0.12-rc.4 → 3.0.12-rc.5

package/store/__tests__/slideInPanel.test.ts

@@ -0,0 +1,88 @@
+import slideInPanelStore from '../slideInPanel';
+
+describe('slideInPanel store', () => {
+  let s: ReturnType<typeof slideInPanelStore.state>;
+  const fakeComponent = { name: 'FakePanel' } as any;
+
+  beforeEach(() => {
+    s = slideInPanelStore.state();
+    jest.useFakeTimers();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  describe('state', () => {
+    it('returns initial default state', () => {
+      expect(s.isOpen).toBe(false);
+      expect(s.isClosing).toBe(false);
+      expect(s.component).toBeNull();
+      expect(s.componentProps).toStrictEqual({});
+    });
+  });
+
+  describe('mutations', () => {
+    describe('open', () => {
+      it('sets isOpen to true', () => {
+        slideInPanelStore.mutations.open(s, { component: fakeComponent });
+
+        expect(s.isOpen).toBe(true);
+      });
+
+      it('stores the component reference', () => {
+        slideInPanelStore.mutations.open(s, { component: fakeComponent });
+
+        expect(s.component).toBe(fakeComponent);
+      });
+
+      it('sets componentProps from payload', () => {
+        slideInPanelStore.mutations.open(s, { component: fakeComponent, componentProps: { title: 'Test' } });
+
+        expect(s.componentProps).toStrictEqual({ title: 'Test' });
+      });
+
+      it('defaults componentProps to empty object when not provided', () => {
+        slideInPanelStore.mutations.open(s, { component: fakeComponent });
+
+        expect(s.componentProps).toStrictEqual({});
+      });
+    });
+
+    describe('close', () => {
+      beforeEach(() => {
+        slideInPanelStore.mutations.open(s, { component: fakeComponent, componentProps: { title: 'Test' } });
+      });
+
+      it('sets isClosing to true immediately', () => {
+        slideInPanelStore.mutations.close(s);
+
+        expect(s.isClosing).toBe(true);
+      });
+
+      it('sets isOpen to false immediately', () => {
+        slideInPanelStore.mutations.close(s);
+
+        expect(s.isOpen).toBe(false);
+      });
+
+      it('retains component and componentProps before the 500ms delay elapses', () => {
+        slideInPanelStore.mutations.close(s);
+        jest.advanceTimersByTime(499);
+
+        expect(s.component).toBe(fakeComponent);
+        expect(s.componentProps).toStrictEqual({ title: 'Test' });
+        expect(s.isClosing).toBe(true);
+      });
+
+      it('clears component, componentProps and isClosing after 500ms', () => {
+        slideInPanelStore.mutations.close(s);
+        jest.advanceTimersByTime(500);
+
+        expect(s.component).toBeNull();
+        expect(s.componentProps).toStrictEqual({});
+        expect(s.isClosing).toBe(false);
+      });
+    });
+  });
+});

package/store/__tests__/type-map.utils.test.ts

@@ -0,0 +1,433 @@
+import {
+  conditionalDepaginate,
+  configureConditionalDepaginate,
+  headerFromSchemaCol,
+  rowValueGetter,
+} from '../type-map.utils';
+
+const makeGetters = (overrides: any = {}) => ({
+  'i18n/exists': jest.fn(() => false),
+  'i18n/t':      jest.fn((key: string) => key),
+  currentStore:  jest.fn(() => 'cluster'),
+  'cluster/all': jest.fn(() => []),
+  ...overrides,
+});
+
+const makeCol = (overrides: any = {}) => ({
+  description: '',
+  field:       '$.metadata.name',
+  format:      '',
+  name:        'Name',
+  priority:    0,
+  type:        'string',
+  ...overrides,
+});
+
+const makeAgeColumn = () => ({
+  name:  'age',
+  label: 'Age',
+  value: 'metadata.creationTimestamp',
+  sort:  ['metadata.creationTimestamp'],
+});
+
+describe('rowValueGetter', () => {
+  describe('fields matching $.metadata.fields[N] pattern', () => {
+    it.each([
+      {
+        desc:          'returns function accessing index 0',
+        field:         '$.metadata.fields[0]',
+        asFn:          true as const,
+        expectedValue: { metadata: { fields: ['first', 'second'] } },
+        expectedIdx:   0,
+      },
+      {
+        desc:          'returns function accessing index 2',
+        field:         '$.metadata.fields[2]',
+        asFn:          true as const,
+        expectedValue: { metadata: { fields: ['a', 'b', 'c'] } },
+        expectedIdx:   2,
+      },
+    ])('$desc', ({
+      field, asFn, expectedValue, expectedIdx,
+    }) => {
+      const getter = rowValueGetter(makeCol({ field }), asFn) as (row: any) => any;
+
+      expect(typeof getter).toStrictEqual('function');
+      expect(getter(expectedValue)).toStrictEqual(expectedValue.metadata.fields[expectedIdx]);
+    });
+
+    it.each([
+      {
+        desc:     'returns string path for index 0',
+        field:    '$.metadata.fields[0]',
+        asFn:     false as const,
+        expected: 'metadata.fields.0',
+      },
+      {
+        desc:     'returns string path for index 3',
+        field:    '$.metadata.fields[3]',
+        asFn:     false as const,
+        expected: 'metadata.fields.3',
+      },
+    ])('$desc', ({ field, asFn, expected }) => {
+      expect(rowValueGetter(makeCol({ field }), asFn)).toStrictEqual(expected);
+    });
+
+    it('returns undefined when row has no fields array', () => {
+      const getter = rowValueGetter(makeCol({ field: '$.metadata.fields[0]' }), true) as (row: any) => any;
+
+      expect(getter({})).toBeUndefined();
+    });
+
+    it('returns undefined when metadata is missing', () => {
+      const getter = rowValueGetter(makeCol({ field: '$.metadata.fields[1]' }), true) as (row: any) => any;
+
+      expect(getter({ other: 'data' })).toBeUndefined();
+    });
+  });
+
+  describe('fields starting with . (dot-prefixed)', () => {
+    it('prepends $ to dot-prefixed fields', () => {
+      const result = rowValueGetter(makeCol({ field: '.metadata.name' }), false);
+
+      expect(result).toStrictEqual('$.metadata.name');
+    });
+
+    it('does not modify fields already starting with $', () => {
+      const result = rowValueGetter(makeCol({ field: '$.metadata.name' }), false);
+
+      expect(result).toStrictEqual('$.metadata.name');
+    });
+  });
+
+  describe('fields with escaped dots (rewriteJsonPath)', () => {
+    it.each([
+      {
+        desc:     'rewrites single escaped dot in label key',
+        field:    '$.metadata.labels.topology\\.kubernetes\\.io/zone',
+        expected: '$.metadata.labels.["topology.kubernetes.io/zone"]',
+      },
+      {
+        desc:     'rewrites escaped dot in annotation key',
+        field:    '$.metadata.annotations.cattle\\.io/hash',
+        expected: '$.metadata.annotations.["cattle.io/hash"]',
+      },
+    ])('$desc', ({ field, expected }) => {
+      expect(rowValueGetter(makeCol({ field }), false)).toStrictEqual(expected);
+    });
+
+    it('returns path unchanged when no escaped dots present', () => {
+      const field = '$.metadata.labels.app';
+
+      expect(rowValueGetter(makeCol({ field }), false)).toStrictEqual(field);
+    });
+  });
+});
+
+describe('conditionalDepaginate', () => {
+  it.each([
+    {
+      desc:       'returns true when depaginate is boolean true',
+      depaginate: true,
+      args:       undefined,
+      expected:   true,
+    },
+    {
+      desc:       'returns false when depaginate is boolean false',
+      depaginate: false,
+      args:       undefined,
+      expected:   false,
+    },
+    {
+      desc:       'returns undefined when depaginate is undefined',
+      depaginate: undefined,
+      args:       undefined,
+      expected:   undefined,
+    },
+  ])('$desc', ({ depaginate, args, expected }) => {
+    expect(conditionalDepaginate(depaginate as any, args)).toStrictEqual(expected);
+  });
+
+  it('calls function with args and returns its result when args are provided', () => {
+    const fn = jest.fn(() => true);
+    const args = { ctx: { rootGetters: {} as any }, args: { type: 'pod', opt: {} } };
+
+    const result = conditionalDepaginate(fn, args);
+
+    expect(fn).toHaveBeenCalledWith(args);
+    expect(result).toStrictEqual(true);
+  });
+
+  it('returns false when depaginate is a function but no args are provided', () => {
+    const fn = jest.fn(() => true);
+
+    expect(conditionalDepaginate(fn, undefined)).toStrictEqual(false);
+    expect(fn).not.toHaveBeenCalled();
+  });
+});
+
+describe('configureConditionalDepaginate', () => {
+  const makeRootGetters = (resourceCount: number | undefined, type: string, store = 'cluster') => {
+    const counts: any = {};
+
+    if (resourceCount !== undefined) {
+      counts[type] = { summary: { count: resourceCount } };
+    }
+
+    return {
+      currentStore:       jest.fn(() => store),
+      [`${ store }/all`]: jest.fn(() => [{ counts }]),
+    };
+  };
+
+  it('returns true when resource count is below maxResourceCount', () => {
+    const type = 'pod';
+    const rootGetters = makeRootGetters(50, type) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: false });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(true);
+  });
+
+  it('returns false when resource count equals maxResourceCount', () => {
+    const type = 'pod';
+    const rootGetters = makeRootGetters(100, type) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: false });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(false);
+  });
+
+  it('returns false when resource count exceeds maxResourceCount', () => {
+    const type = 'pod';
+    const rootGetters = makeRootGetters(200, type) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: false });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(false);
+  });
+
+  it('returns false when resource count is undefined', () => {
+    const type = 'pod';
+    const rootGetters = makeRootGetters(undefined, type) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: false });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(false);
+  });
+
+  it('uses management.cattle.io. prefix for Norman types', () => {
+    const type = 'node';
+    const normanType = `management.cattle.io.${ type }`;
+    const rootGetters = makeRootGetters(5, normanType) as any;
+    const fn = configureConditionalDepaginate({ maxResourceCount: 100, isNorman: true });
+    const result = fn({
+      ctx:  { rootGetters },
+      args: { type, opt: {} },
+    });
+
+    expect(result).toStrictEqual(true);
+  });
+});
+
+describe('headerFromSchemaCol', () => {
+  describe('age column shortcut', () => {
+    it.each([
+      {
+        desc: 'returns ageColumn when format is empty and name is age',
+        col:  makeCol({
+          name:   'age',
+          format: '',
+        }),
+      },
+      {
+        desc: 'returns ageColumn when format is date and name is age',
+        col:  makeCol({
+          name:   'age',
+          format: 'date',
+        }),
+      },
+      {
+        desc: 'returns ageColumn when type is date and name is age',
+        col:  makeCol({
+          name:   'age',
+          type:   'date',
+          format: '',
+        }),
+      },
+      {
+        desc: 'returns ageColumn when name is Age (case insensitive)',
+        col:  makeCol({
+          name:   'Age',
+          format: '',
+        }),
+      },
+    ])('$desc', ({ col }) => {
+      const ageColumn = makeAgeColumn() as any;
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, ageColumn);
+
+      expect(result).toStrictEqual(ageColumn);
+    });
+
+    it('does not return ageColumn when ageColumn is not provided', () => {
+      const col = makeCol({ name: 'age', format: '' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result).not.toStrictEqual(null);
+      expect(result.name).toStrictEqual('age');
+    });
+  });
+
+  describe('formatter assignment', () => {
+    it('sets formatter to Date and width 120 for date format', () => {
+      const col = makeCol({
+        name:   'created',
+        format: 'date',
+      });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toStrictEqual('Date');
+      expect(result.width).toStrictEqual(120);
+      expect(result.formatterOpts).toStrictEqual({ multiline: true });
+    });
+
+    it('sets formatter to Date and width 120 when type is date', () => {
+      const col = makeCol({
+        name:   'modified',
+        format: '',
+        type:   'date',
+      });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toStrictEqual('Date');
+      expect(result.width).toStrictEqual(120);
+    });
+
+    it('sets formatter to Number when type is number', () => {
+      const col = makeCol({
+        name: 'count',
+        type: 'number',
+      });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toStrictEqual('Number');
+    });
+
+    it('sets formatter to Number when type is int', () => {
+      const col = makeCol({
+        name: 'replicas',
+        type: 'int',
+      });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toStrictEqual('Number');
+    });
+
+    it('does not set formatter for plain text column', () => {
+      const col = makeCol({ name: 'status', type: 'string' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.formatter).toBeUndefined();
+    });
+  });
+
+  describe('label resolution', () => {
+    it('uses i18n translation when key exists', () => {
+      const getters = makeGetters({
+        'i18n/exists': jest.fn(() => true),
+        'i18n/t':      jest.fn((key: string) => `translated:${ key }`),
+      });
+      const col = makeCol({ name: 'status' });
+      const result = headerFromSchemaCol(col as any, getters as any, false, null as any);
+
+      expect(result.label).toStrictEqual('translated:tableHeaders.status');
+    });
+
+    it('uses column name when i18n key does not exist', () => {
+      const getters = makeGetters({ 'i18n/exists': jest.fn(() => false) });
+      const col = makeCol({ name: 'MyColumn' });
+      const result = headerFromSchemaCol(col as any, getters as any, false, null as any);
+
+      expect(result.label).toStrictEqual('MyColumn');
+    });
+
+    it('camelCases the i18n key when col name has spaces', () => {
+      const getters = makeGetters({
+        'i18n/exists': jest.fn((key: string) => key === 'tableHeaders.myLabel'),
+        'i18n/t':      jest.fn((key: string) => `t:${ key }`),
+      });
+      const col = makeCol({ name: 'my label' });
+      const result = headerFromSchemaCol(col as any, getters as any, false, null as any);
+
+      expect(result.label).toStrictEqual('t:tableHeaders.myLabel');
+    });
+  });
+
+  describe('tooltip from description', () => {
+    it('uses description as tooltip when not ending with dot', () => {
+      const col = makeCol({ name: 'status', description: 'Current status' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.tooltip).toStrictEqual('Current status');
+    });
+
+    it('strips trailing dot from description for tooltip', () => {
+      const col = makeCol({ name: 'status', description: 'Current status.' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.tooltip).toStrictEqual('Current status');
+    });
+
+    it('uses empty string as tooltip when description is empty', () => {
+      const col = makeCol({ name: 'status', description: '' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.tooltip).toStrictEqual('');
+    });
+  });
+
+  describe('pagination mode', () => {
+    it('uses string path as value when pagination is true', () => {
+      const col = makeCol({ name: 'status', field: '$.metadata.name' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, true, null as any);
+
+      expect(typeof result.value).toStrictEqual('string');
+    });
+
+    it('uses function as value when pagination is false', () => {
+      const col = makeCol({ name: 'status', field: '$.metadata.fields[0]' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(typeof result.value).toStrictEqual('function');
+    });
+  });
+
+  describe('output shape', () => {
+    it('sets name to lowercase version of col.name', () => {
+      const col = makeCol({ name: 'Status' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, false, null as any);
+
+      expect(result.name).toStrictEqual('status');
+    });
+
+    it('sets sort and search from string path', () => {
+      const col = makeCol({ name: 'name', field: '$.metadata.name' });
+      const result = headerFromSchemaCol(col as any, makeGetters() as any, true, null as any);
+
+      expect(result.sort).toStrictEqual(['$.metadata.name']);
+      expect(result.search).toStrictEqual('$.metadata.name');
+    });
+  });
+});

package/store/features.js

@@ -39,6 +39,10 @@ export const PROVISIONING_PRE_BOOTSTRAP = create('provisioningprebootstrap', fal
 export const SCHEDULING_CUSTOMIZATION = create(SCHEDULING_CUSTOMIZATION_FEATURE, false);
 export const SCC = create('rancher-scc-registration-extension', true);
 export const AUTOSCALER = create('cluster-autoscaling', false);
+// Feature flags for disabling shell access to clusters, nodes, pods
+export const CLUSTER_SHELL = create('cluster-shell', true);
+export const NODE_SHELL = create('node-shell', true);
+export const POD_SHELL = create('pod-shell', true);
 
 // Not currently used.. no point defining ones we don't use
 // export const EMBEDDED_CLUSTER_API = create('embedded-cluster-api', true);

package/types/shell/index.d.ts

@@ -141,6 +141,9 @@ export namespace SNAPSHOT {
     let CLUSTER_NAME_1: string;
     export { CLUSTER_NAME_1 as CLUSTER_NAME };
 }
+export namespace OPERATION_ANNOTATIONS {
+    let ENABLED: string;
+}
 export namespace ISTIO {
     let AUTO_INJECTION: string;
 }
@@ -309,6 +312,9 @@ export namespace SNAPSHOT {
     let CLUSTER_NAME_1: string;
     export { CLUSTER_NAME_1 as CLUSTER_NAME };
 }
+export namespace OPERATION_ANNOTATIONS {
+    let ENABLED: string;
+}
 export namespace ISTIO {
     let AUTO_INJECTION: string;
 }
@@ -4511,6 +4517,11 @@ export const LONGHORN_DRIVER: "driver.longhorn.io";
 export const LONGHORN_VERSION_V1: "LonghornV1";
 export const LONGHORN_VERSION_V2: "LonghornV2";
 export const SNAPSHOT: "rke.cattle.io.etcdsnapshot";
+export namespace OPERATION {
+    let ETCD_SNAPSHOT: string;
+    let ETCD_SNAPSHOT_RESTORE: string;
+    let ENCRYPTION_KEY_ROTATE: string;
+}
 export namespace MANAGEMENT {
     let AUTH_CONFIG_1: string;
     export { AUTH_CONFIG_1 as AUTH_CONFIG };
@@ -4688,6 +4699,7 @@ export namespace AUTH_TYPE {
     let _S3: string;
     let _RKE: string;
     let _IMAGE_PULL_SECRET: string;
+    let _GITHUB_APP: string;
 }
 export const LOCAL_CLUSTER: "local";
 export namespace CLUSTER_REPO_TYPES {
@@ -4896,6 +4908,11 @@ export const LONGHORN_DRIVER: "driver.longhorn.io";
 export const LONGHORN_VERSION_V1: "LonghornV1";
 export const LONGHORN_VERSION_V2: "LonghornV2";
 export const SNAPSHOT: "rke.cattle.io.etcdsnapshot";
+export namespace OPERATION {
+    let ETCD_SNAPSHOT: string;
+    let ETCD_SNAPSHOT_RESTORE: string;
+    let ENCRYPTION_KEY_ROTATE: string;
+}
 export namespace MANAGEMENT {
     let AUTH_CONFIG_1: string;
     export { AUTH_CONFIG_1 as AUTH_CONFIG };
@@ -5073,6 +5090,7 @@ export namespace AUTH_TYPE {
     let _S3: string;
     let _RKE: string;
     let _IMAGE_PULL_SECRET: string;
+    let _GITHUB_APP: string;
 }
 export const LOCAL_CLUSTER: "local";
 export namespace CLUSTER_REPO_TYPES {
@@ -6624,6 +6642,7 @@ export namespace STATES_ENUM {
     let BUILDING: string;
     let COMPLETED: string;
     let CORDONED: string;
+    let CANCELLED: string;
     let COUNT: string;
     let CREATED: string;
     let CREATING: string;
@@ -6862,6 +6881,8 @@ export default class Resource {
     doActionGrowl(actionName: any, body: any, opt?: {}): Promise<any>;
     patch(data: any, opt?: {}, merge?: boolean, alertOnError?: boolean): any;
     save(...args: any[]): Promise<this>;
+    _collectionUrl(): any;
+    dryRunCreate(data: any): Promise<any>;
     /**
      * Remove any unwanted properties from the object that will be saved
      */
@@ -7202,6 +7223,7 @@ export namespace STATES_ENUM {
     let BUILDING: string;
     let COMPLETED: string;
     let CORDONED: string;
+    let CANCELLED: string;
     let COUNT: string;
     let CREATED: string;
     let CREATING: string;
@@ -7440,6 +7462,8 @@ export default class Resource {
     doActionGrowl(actionName: any, body: any, opt?: {}): Promise<any>;
     patch(data: any, opt?: {}, merge?: boolean, alertOnError?: boolean): any;
     save(...args: any[]): Promise<this>;
+    _collectionUrl(): any;
+    dryRunCreate(data: any): Promise<any>;
     /**
      * Remove any unwanted properties from the object that will be saved
      */
@@ -7901,6 +7925,9 @@ export const PROVISIONING_PRE_BOOTSTRAP: any;
 export const SCHEDULING_CUSTOMIZATION: any;
 export const SCC: any;
 export const AUTOSCALER: any;
+export const CLUSTER_SHELL: any;
+export const NODE_SHELL: any;
+export const POD_SHELL: any;
 export namespace getters {
     function get(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
 }
@@ -7934,6 +7961,9 @@ export const PROVISIONING_PRE_BOOTSTRAP: any;
 export const SCHEDULING_CUSTOMIZATION: any;
 export const SCC: any;
 export const AUTOSCALER: any;
+export const CLUSTER_SHELL: any;
+export const NODE_SHELL: any;
+export const POD_SHELL: any;
 export namespace getters {
     function get(state: any, getters: any, rootState: any, rootGetters: any): (name: any) => any;
 }
@@ -9765,6 +9795,38 @@ export function convertStringToKV(input: string): {};
 declare function isEqualBasic(from: any, to: any): boolean;
 }
 
+// @shell/utils/operation-cr
+
+declare module '@shell/utils/operation-cr' {
+/**
+ * Create a day 2 operation CR for imported clusters.
+ *
+ * @param {Function} dispatch - The Vuex dispatch function
+ * @param {string} type - The operation CRD type
+ * @param {object} spec - The operation spec
+ * @param {string} namespace - The namespace for the operation CR
+ * @param {string} namePrefix - The name prefix for the generated name
+ * @returns {Promise} The saved resource
+ */
+export function createOperationCR(dispatch: Function, type: string, spec: object, namespace: string, namePrefix: string): Promise<any>;
+}
+
+// @shell/utils/operation-cr.js
+
+declare module '@shell/utils/operation-cr.js' {
+/**
+ * Create a day 2 operation CR for imported clusters.
+ *
+ * @param {Function} dispatch - The Vuex dispatch function
+ * @param {string} type - The operation CRD type
+ * @param {object} spec - The operation spec
+ * @param {string} namespace - The namespace for the operation CR
+ * @param {string} namePrefix - The name prefix for the generated name
+ * @returns {Promise} The saved resource
+ */
+export function createOperationCR(dispatch: Function, type: string, spec: object, namespace: string, namePrefix: string): Promise<any>;
+}
+
 // @shell/utils/parse-externalid
 
 declare module '@shell/utils/parse-externalid' {