devops-plugin-kit 0.1.0

package/@danieli-automation/devops-plugin-core/src/core/storage/hooks/useTaskOrder.ts

@@ -0,0 +1,125 @@
+/**
+ * @description: Task order storage hooks using React Query.
+ * Provides hooks for querying and mutating task order preferences.
+ * Utilizes zustand stores for persistent storage and caching.
+ * Ensures data consistency by updating the query cache on successful mutations.
+ */
+
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { TaskOrderType } from "core/types/taskOrder/TaskOrderType";
+import { AdoWorkItemType } from "core/types/AdoWorkItemType";
+import { QUERY_KEYS, STORAGE_KEYS } from "../keys";
+import { loadTaskOrder, saveTaskOrder } from "../repositories/taskOrder";
+
+/**
+ * Load task ordering preference for a given instance.
+ *
+ * @param instanceId The instance id to scope the task order to.
+ * @returns React Query result containing the task order.
+ */
+export function useTaskOrderQuery(instanceId: string | null | undefined) {
+    const isSharedInstance = !!instanceId;
+
+    return useQuery({
+        queryKey: [QUERY_KEYS.prefs, QUERY_KEYS.taskOrder, instanceId],
+        enabled: isSharedInstance,
+        queryFn: () => loadTaskOrder(instanceId),
+        staleTime: Infinity,
+        cacheTime: 1,
+        keepPreviousData: false,
+        // Keep shared-instance task order in sync across owners/viewers.
+        refetchInterval: isSharedInstance ? 5000 : false,
+        refetchOnWindowFocus: isSharedInstance,
+        refetchOnReconnect: isSharedInstance,
+    });
+}
+
+/**
+ * Save task ordering preference
+ *
+ * Persists task order rows for the given instance (or personal scope),
+ * and updates the query cache on success.
+ *
+ * @param instanceId The instance id or null for personal order.
+ * @returns React Query mutation for saving task order.
+ */
+export function useSaveTaskOrder(instanceId: string | null | undefined) {
+    const qc = useQueryClient();
+    const effectiveId = instanceId ?? STORAGE_KEYS.personalTaskOrder;
+    return useMutation({
+        mutationFn: (rows: TaskOrderType[]) => saveTaskOrder(effectiveId, rows),
+        onSuccess: (_, rows) => {
+            qc.setQueryData([QUERY_KEYS.prefs, QUERY_KEYS.taskOrder, effectiveId], rows);
+        },
+    });
+}
+
+export function buildNormalizedTaskOrder(tasksInCurrentOrder: AdoWorkItemType[], stored: TaskOrderType[]): TaskOrderType[] {
+    if (!tasksInCurrentOrder.length) return [];
+
+    const byParent = new Map<number, AdoWorkItemType[]>();
+    for (const t of tasksInCurrentOrder) {
+        if (typeof t.id !== "number") continue;
+        const pid = getParentIdFromTask(t);
+        if (pid == null || Number.isNaN(pid)) continue;
+        const arr = byParent.get(pid) ?? [];
+        arr.push(t);
+        byParent.set(pid, arr);
+    }
+
+    const storedByParent = new Map<number, TaskOrderType[]>();
+    for (const r of stored ?? []) {
+        const arr = storedByParent.get(r.parentId) ?? [];
+        arr.push(r);
+        storedByParent.set(r.parentId, arr);
+    }
+
+    const normalized: TaskOrderType[] = [];
+
+    Array.from(byParent.entries()).forEach(([parentId, tasks]) => {
+        const storedRows = storedByParent.get(parentId) ?? [];
+        const byId = new Map(storedRows.map(r => [r.id, r.order]));
+
+        const looksIdBasedOrMissing =
+            storedRows.length > 0 &&
+            storedRows.every(r => !r.order || r.order === r.id);
+
+        let ordered = tasks.map((t) => ({
+            id: t.id as number,
+            order: byId.get(t.id as number) ?? Number.MAX_SAFE_INTEGER,
+        }));
+
+        if (looksIdBasedOrMissing || storedRows.length === 0) {
+            ordered = tasks.map((t, idx) => ({ id: t.id as number, order: idx + 1 }));
+        } else {
+            ordered.sort((a, b) => a.order - b.order || a.id - b.id);
+            ordered = ordered.map((r, idx) => ({ id: r.id, order: idx + 1 }));
+        }
+
+        ordered.forEach((r) => {
+            normalized.push({
+                id: r.id,
+                parentId,
+                order: r.order,
+            });
+        });
+    });
+
+    return normalized;
+}
+
+function getParentIdFromTask(task: AdoWorkItemType): number | null {
+    if (typeof task.parentWorkItem?.id === "number") {
+        return task.parentWorkItem.id;
+    }
+
+    const parentRel = task.relations?.find((rel) => rel?.rel === "System.LinkTypes.Hierarchy-Reverse");
+    if (!parentRel?.url) {
+        return null;
+    }
+
+    const segments = parentRel.url.split("/");
+    const idRaw = segments[segments.length - 1];
+    const id = Number(idRaw);
+    return Number.isFinite(id) ? id : null;
+}

package/@danieli-automation/devops-plugin-core/src/core/storage/hooks/useWorkItemOrder.ts

@@ -0,0 +1,86 @@
+/**
+ * @description: Column Preference storage hooks using React Query.
+ * Provides hooks for querying and mutating
+ * Utilizes zustand stores for persistent storage and caching.
+ * Ensures data consistency by updating the query cache on successful mutations.
+ */
+
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { WorkItemOrderType } from "core/types/workItemOrder/WorkItemOrderType";
+import { QUERY_KEYS, STORAGE_KEYS } from "../keys";
+import { loadWorkItemOrder, saveWorkItemOrder } from "../repositories/workItemOrder";
+
+/** Global (unscoped) hooks
+ *
+ * Load work item ordering preference for a given instance.
+ *
+ * @param instanceId The instance id to scope the backlog order to.
+ * @returns React Query result containing the backlog order.
+ */
+export function useWorkItemOrderQuery(instanceId: string | null | undefined) {
+    const isSharedInstance = !!instanceId;
+
+    return useQuery({
+        queryKey: [QUERY_KEYS.prefs, QUERY_KEYS.backlogOrder, instanceId],
+        enabled: isSharedInstance,
+        queryFn: () => loadWorkItemOrder(instanceId),
+        staleTime: Infinity,
+        cacheTime: 1,
+        keepPreviousData: false,
+        // Keep shared-instance work item order in sync across owners/viewers.
+        refetchInterval: isSharedInstance ? 5000 : false,
+        refetchOnWindowFocus: isSharedInstance,
+        refetchOnReconnect: isSharedInstance,
+    });
+}
+
+/** Save work item ordering preference
+ *
+ * Persists work item order rows for the given instance (or personal scope),
+ * and updates the query cache on success.
+ *
+ * @param instanceId The instance id or null for personal order.
+ * @returns React Query mutation for saving backlog order.
+ */
+export function useSaveWorkItemOrder(instanceId: string | null | undefined) {
+    const qc = useQueryClient();
+    const effectiveId = instanceId ?? STORAGE_KEYS.personalOrder;
+    return useMutation({
+        mutationFn: (rows: WorkItemOrderType[]) => saveWorkItemOrder(effectiveId, rows),
+        onSuccess: (_, rows) => {
+            qc.setQueryData([QUERY_KEYS.prefs, QUERY_KEYS.backlogOrder, effectiveId], rows);
+        },
+    });
+}
+
+export function buildNormalizedOrder(itemsInCurrentOrder: { id: number }[], stored: WorkItemOrderType[]): WorkItemOrderType[] {
+    if (!itemsInCurrentOrder.length) return [];
+
+    if (!stored || stored.length === 0) {
+        // no stored order -> just 1..N
+        return itemsInCurrentOrder.map((wi, idx) => ({ id: wi.id, order: idx + 1 }));
+    }
+
+    // index by id for fast lookup
+    const byId = new Map(stored.map(r => [r.id, r.order]));
+
+    // detect if everything looks like "ID as order" or invalid (0/undefined)
+    const looksIdBasedOrMissing = stored.length > 0 && stored.every(r =>
+        !r.order || r.order === r.id
+    );
+
+    if (looksIdBasedOrMissing) {
+        // treat as no real order -> regenerate 1..N from current order
+        return itemsInCurrentOrder.map((wi, idx) => ({ id: wi.id, order: idx + 1 }));
+    }
+
+    // we have at least one “real” order – use it, but normalize and ensure 1..N
+    const existingForCurrent = itemsInCurrentOrder
+        .map(wi => ({
+            id: wi.id,
+            order: byId.get(wi.id) ?? Number.MAX_SAFE_INTEGER, // unseen ids go to the end
+        }))
+        .sort((a, b) => a.order - b.order || a.id - b.id) // stable-ish fallback
+
+    return existingForCurrent.map((r, idx) => ({ id: r.id, order: idx + 1 }));
+}

package/@danieli-automation/devops-plugin-core/src/core/storage/index.ts

@@ -0,0 +1,13 @@
+/**
+ * @description: Stores for user preferences using Key-Value Store abstraction.
+ * Provides stores for backlog order, column preferences, dialog rows, and saved rows.
+ * Utilizes createKVStore to create typed stores for specific storage keys.
+ */
+
+import { createKVStore } from "./createStore";
+import { STORAGE_KEYS } from "./keys";
+
+export const backlogOrderStore = createKVStore<Array<{ id: number; order: number }>>(STORAGE_KEYS.personalOrder);
+export const columnPrefsStore = createKVStore<{ order: string[]; visible: string[] }>(STORAGE_KEYS.columnPrefs);
+export const dialogRowsStore = createKVStore<any[]>(STORAGE_KEYS.dialogRows);
+export const savedRowsStore = createKVStore<any>(STORAGE_KEYS.savedRows);

package/@danieli-automation/devops-plugin-core/src/core/storage/keys.ts

@@ -0,0 +1,31 @@
+/**
+ * @description: Stores for user preferences using Key-Value Store abstraction.
+ * Provides stores for backlog order, column preferences, dialog rows, and saved rows.
+ * Utilizes createKVStore to create typed stores for specific storage keys.
+ */
+
+import { ScopeType } from "core/types/ScopeType";
+
+export const STORAGE_KEYS = {
+    columnPrefs: "crossTeamColumnPrefs",
+    dialogRows: "crossTeamDialogRows",
+    savedRows: "crossTeamSavedRows",
+    crossTeamInstances: "crossTeamInstances",
+    crossTeamDefaultInstance: "crossTeamDefaultInstance",
+    personalOrder: "personalBacklogOrder",
+    personalTaskOrder: "personalTaskOrder"
+};
+
+export const QUERY_KEYS = {
+    prefs: "prefs",
+    taskOrder: "taskOrder",
+    columns: "columns",
+    dialowRows: "dialogRows",
+    instances: "instances",
+    crossSprint: "cross-sprint",
+    defaultInstancePref: "defaultInstancePref",
+    backlogOrder: "backlogOrder" //workitem order
+}
+
+const SCOPE = process.env.SCOPE as ScopeType | undefined;
+export const DEFAULT_SCOPE: ScopeType = SCOPE || "User";

package/@danieli-automation/devops-plugin-core/src/core/storage/repositories/instance.ts

@@ -0,0 +1,184 @@
+import { CreateInstanceInput } from "core/types/instance/CreateInstanceInputType";
+import type { CrossSprintInstanceMap, CrossSprintInstanceType } from "core/types/instance/CrossSprintInstanceType";
+import { UpdateInstanceInput } from "core/types/instance/UpdateInstanceInputType";
+import type { WorkItemOrderMapType } from "core/types/workItemOrder/WorkItemOrderMapType";
+import { crossTeamInstancesStore, defaultInstanceStore, workItemOrderStore } from "../stores";
+
+
+/**
+ * Load all stored Cross Sprint instances.
+ *
+ * Reads the instance map from storage and returns it as an array.
+ *
+ * @returns A list of instances, or an empty array if none exist.
+ */
+export async function loadAllInstances(): Promise<CrossSprintInstanceType[]> {
+    const stored = await crossTeamInstancesStore.load();
+
+    if (!stored) return [];
+
+    return Object.values(stored);
+}
+
+/**
+ * Load the default Cross Sprint instance.
+ *
+ * Reads the stored default instance preference, then looks up
+ * the corresponding instance from all persisted instances.
+ *
+ * @returns The default Cross Sprint instance if defined and found,
+ *          otherwise undefined.
+ */
+export async function loadDefaultInstance() {
+    const defaultPref = await defaultInstanceStore.load();
+    const allInstances = await loadAllInstances();
+
+    if (!defaultPref?.id) return undefined;
+
+    return allInstances.find((i) => i.id === defaultPref.id);
+}
+
+/**
+ * Load a single Cross Sprint instance by id.
+ *
+ * Reads the instance map from storage, finds the instance,
+ * and normalizes it (ensuring `owners` fallback behavior).
+ *
+ * @param id Instance id to load.
+ * @returns The found instance (normalized) or undefined if not found.
+ */
+export async function loadInstanceById(id: string): Promise<CrossSprintInstanceType | undefined> {
+    const stored = await crossTeamInstancesStore.load();
+    if (!stored) return undefined;
+    const inst = stored[id];
+    return inst ? normalizeInstance(inst) : undefined;
+}
+
+/**
+ * Create and persist a new Cross Sprint instance.
+ *
+ * Generates an id, sets timestamps, applies owners fallback,
+ * and saves the new instance into the instance map in storage.
+ *
+ * @param input New instance fields.
+ * @returns The created instance object.
+ */
+export async function createCrossSprintInstance(input: CreateInstanceInput): Promise<CrossSprintInstanceType> {
+    const { name, description, org, createdBy, owners, projectTeamPairs, } = input;
+
+    const now = new Date().toISOString();
+    const id = crypto.randomUUID() ?? Math.random().toString(36).substring(2, 15);
+
+    const instance: CrossSprintInstanceType = {
+        id,
+        name,
+        description,
+        org,
+        createdBy,
+        owners: owners && owners.length > 0 ? owners : [createdBy],
+        projectTeamPairs,
+        isDefault: false,
+        createdAt: now,
+        updatedAt: now,
+    };
+
+    const stored = await crossTeamInstancesStore.load();
+    const current: CrossSprintInstanceMap = stored ?? {};
+
+    const next: CrossSprintInstanceMap = {
+        ...current,
+        [id]: instance,
+    };
+
+    await crossTeamInstancesStore.save(next);
+
+    return instance;
+}
+
+/**
+ * Update an existing Cross Sprint instance.
+ *
+ * Reads the instance map, finds the target instance, and applies partial updates:
+ * - Only provided fields override existing values.
+ * - Always updates `updatedAt`.
+ *
+ * @param input Partial update payload containing the instance id and changed fields.
+ * @returns The updated instance, or undefined if storage/instance is missing.
+ */
+export async function updateCrossSprintInstance(input: UpdateInstanceInput): Promise<CrossSprintInstanceType | undefined> {
+    const stored = await crossTeamInstancesStore.load();
+    if (!stored) return undefined;
+
+    const { id, name, description, owners, projectTeamPairs, isDefault } = input;
+
+    const existing = stored[id];
+    if (!existing) return undefined;
+
+    const updated: CrossSprintInstanceType = {
+        ...existing,
+        name: name ?? existing.name,
+        description: description ?? existing.description,
+        projectTeamPairs: projectTeamPairs ?? existing.projectTeamPairs,
+        owners: owners ?? existing.owners,
+        isDefault: isDefault ?? existing.isDefault,
+        updatedAt: new Date().toISOString(),
+    };
+
+    const next: CrossSprintInstanceMap = {
+        ...stored,
+        [id]: updated,
+    };
+
+    await crossTeamInstancesStore.save(next);
+
+    return updated;
+}
+
+/**
+ * Delete a Cross Sprint instance and its related backlog order preferences.
+ *
+ * Removes the instance entry from the instances map.
+ * Also removes any backlog order saved under the same instance id.
+ *
+ * @param instanceId Instance id to delete.
+ * @returns Void.
+ */
+export async function deleteCrossTeamInstance(instanceId: string): Promise<void> {
+
+    const instances = await crossTeamInstancesStore.load();
+    if (instances && typeof instances === "object" && !Array.isArray(instances)) {
+        const { [instanceId]: _, ...rest } = instances;
+        await crossTeamInstancesStore.save(rest as CrossSprintInstanceMap);
+    }
+
+    const orders = await workItemOrderStore.load();
+
+    if (Array.isArray(orders) || !orders) return;
+
+    const { [instanceId]: __, ...restOrders } = orders as WorkItemOrderMapType;
+    await workItemOrderStore.save(restOrders as WorkItemOrderMapType);
+}
+
+
+//#region Private Functions
+
+/**
+ * Normalizes a stored instance into a safe shape for consumers.
+ *
+ * Ensures `owners` is always present:
+ * - If `owners` exists and has items, keep it.
+ * - Otherwise fallback to `[createdBy]`.
+ *
+ * @param inst Raw instance object read from storage.
+ * @returns Normalized CrossSprintInstanceType with guaranteed `owners`.
+ */
+function normalizeInstance(inst: any): CrossSprintInstanceType {
+    return {
+        ...inst,
+        owners: inst.owners && inst.owners.length > 0
+            ? inst.owners
+            : [inst.createdBy],
+    };
+}
+
+//#endregion

package/@danieli-automation/devops-plugin-core/src/core/storage/repositories/taskOrder.ts

@@ -0,0 +1,59 @@
+import { TaskOrderMapType } from "core/types/taskOrder/TaskOrderMapType";
+import { TaskOrderType } from "core/types/taskOrder/TaskOrderType";
+import { STORAGE_KEYS } from "../keys";
+import { taskOrderStore } from "../stores";
+
+/**
+ * Save task order for a given instance or personal board.
+ *
+ * Persists task ordering under an instance-specific key.
+ * Falls back to the personal board key when no instance id is provided.
+ * Includes backward compatibility for the legacy array-based schema.
+ *
+ * @param instanceId Instance id or null for personal board.
+ * @param rows Ordered tasks to persist.
+ */
+export async function saveTaskOrder(instanceId: string | null | undefined, rows: TaskOrderType[]): Promise<void> {
+    const key = instanceId ?? STORAGE_KEYS.personalTaskOrder;
+
+    const stored = await taskOrderStore.load();
+
+    // Backward-compat: old schema = plain array
+    if (Array.isArray(stored)) {
+        const map: TaskOrderMapType = { [key]: rows };
+        await taskOrderStore.save(map);
+        return;
+    }
+
+    const current: TaskOrderMapType = stored ?? {};
+    const next: TaskOrderMapType = {
+        ...current,
+        [key]: rows,
+    };
+
+    await taskOrderStore.save(next);
+}
+
+/**
+ * Load task order for a given instance or personal board.
+ *
+ * Resolves task ordering using an instance-specific key.
+ * Falls back to the personal board key when no instance id is provided.
+ * Includes backward compatibility for the legacy array-based schema.
+ *
+ * @param instanceId Instance id or null for personal board.
+ * @returns Ordered tasks array.
+ */
+export async function loadTaskOrder(instanceId: string | null | undefined): Promise<TaskOrderType[]> {
+    const key = instanceId ?? STORAGE_KEYS.personalTaskOrder;
+
+    const stored = await taskOrderStore.load();
+
+    // Backward-compat: old schema = plain array -> treat as personal
+    if (Array.isArray(stored)) {
+        return stored as TaskOrderType[];
+    }
+
+    if (!stored) return [];
+    return stored[key] ?? [];
+}

package/@danieli-automation/devops-plugin-core/src/core/storage/repositories/workItemOrder.ts

@@ -0,0 +1,60 @@
+import { WorkItemOrderMapType } from "core/types/workItemOrder/WorkItemOrderMapType";
+import { WorkItemOrderType } from "core/types/workItemOrder/WorkItemOrderType";
+import { STORAGE_KEYS } from "../keys";
+import { workItemOrderStore } from "../stores";
+
+/**
+ * Save backlog order for a given instance or personal board.
+ *
+ * Persists work item ordering under an instance-specific key.
+ * Falls back to the personal board key when no instance id is provided.
+ * Includes backward compatibility for the legacy array-based schema.
+ *
+ * @param instanceId Instance id or null for personal board.
+ * @param rows Ordered work items to persist.
+ */
+export async function saveWorkItemOrder(instanceId: string | null | undefined, rows: WorkItemOrderType[]): Promise<void> {
+    // Fallback key for personal board
+    const key = instanceId ?? STORAGE_KEYS.personalOrder;
+
+    const stored = await workItemOrderStore.load();
+
+    // Backward-compat: old schema = plain array
+    if (Array.isArray(stored)) {
+        const map: WorkItemOrderMapType = { [key]: rows };
+        await workItemOrderStore.save(map);
+        return;
+    }
+
+    const current: WorkItemOrderMapType = stored ?? {};
+    const next: WorkItemOrderMapType = {
+        ...current,
+        [key]: rows,
+    };
+
+    await workItemOrderStore.save(next);
+}
+
+/**
+ * Load backlog order for a given instance or personal board.
+ *
+ * Resolves work item ordering using an instance-specific key.
+ * Falls back to the personal board key when no instance id is provided.
+ * Includes backward compatibility for the legacy array-based schema.
+ *
+ * @param instanceId Instance id or null for personal board.
+ * @returns Ordered work items array.
+ */
+export async function loadWorkItemOrder(instanceId: string | null | undefined): Promise<WorkItemOrderType[]> {
+    const key = instanceId ?? STORAGE_KEYS.personalOrder;
+
+    const stored = await workItemOrderStore.load();
+
+    // Backward-compat: old schema = plain array → treat as personal
+    if (Array.isArray(stored)) {
+        return stored;
+    }
+
+    if (!stored) return [];
+    return stored[key] ?? [];
+}

package/@danieli-automation/devops-plugin-core/src/core/storage/stores.ts

@@ -0,0 +1,18 @@
+/**
+ * @description: Stores for user preferences using Key-Value Store abstraction.
+ * Provides stores for backlog order, column preferences, dialog rows, and saved rows.
+ * Utilizes createKVStore to create typed stores for specific storage keys.
+ */
+
+import { DefaultInstanceType } from "core/types/instance/DefaultInstanceType";
+import { TaskOrderMapType } from "core/types/taskOrder/TaskOrderMapType";
+import { WorkItemOrderMapType } from "core/types/workItemOrder/WorkItemOrderMapType";
+import { CrossSprintInstanceMap } from "../types/instance/CrossSprintInstanceType";
+import { createKVStore } from "./createStore";
+import { STORAGE_KEYS } from "./keys";
+
+//The scope is set as "Default" so all users see same JM-defined order
+export const workItemOrderStore = createKVStore<WorkItemOrderMapType>(STORAGE_KEYS.personalOrder, "Default");
+export const taskOrderStore = createKVStore<TaskOrderMapType>(STORAGE_KEYS.personalTaskOrder, "Default");
+export const crossTeamInstancesStore = createKVStore<CrossSprintInstanceMap>(STORAGE_KEYS.crossTeamInstances, "Default");
+export const defaultInstanceStore = createKVStore<DefaultInstanceType>(STORAGE_KEYS.crossTeamDefaultInstance, "User");

package/@danieli-automation/devops-plugin-core/src/core/types/AdoWorkItemType.ts

@@ -0,0 +1,18 @@
+import { WorkItemRelation } from "azure-devops-extension-api/WorkItemTracking";
+
+export type AdoWorkItemType = {
+    id: any;
+    tempId?: string;
+    fields: { [key: string]: any };
+    _links?: any;
+    url?: string;
+    order?: number;
+    displayOrder?: string;
+    rev?: number;
+    multiLineFields?: { [k: string]: string[] };
+    relations?: WorkItemRelation[];
+    isNewTask?: boolean;
+    parentWorkItem?: AdoWorkItemType;
+    isFaded?: boolean | undefined;
+    _children?: AdoWorkItemType[];
+};

package/@danieli-automation/devops-plugin-core/src/core/types/KVStoreType.ts

@@ -0,0 +1 @@
+export type KVStore<T> = { load(): Promise<T | undefined>; save(value: T): Promise<void>; };

package/@danieli-automation/devops-plugin-core/src/core/types/ScopeType.ts

@@ -0,0 +1 @@
+export type ScopeType = "User" | "Default";

package/@danieli-automation/devops-plugin-core/src/core/types/SelectedProjectType.ts

@@ -0,0 +1,8 @@
+export type SelectedProjectType = {
+    projectId: string;
+    projectName?: string;
+    teamName?: string;
+    teamId: string;
+    teams?: any[];
+    selectedTeamKey?: string;
+};

package/@danieli-automation/devops-plugin-core/src/core/types/SortConfigType.ts

@@ -0,0 +1,2 @@
+export type SortDirection = "asc" | "desc";
+export type SortConfig = { field: string; direction: SortDirection } | null;

package/@danieli-automation/devops-plugin-core/src/core/types/instance/CreateInstanceInputType.ts

@@ -0,0 +1,10 @@
+import { SelectedProjectType } from "core/types/SelectedProjectType";
+
+export type CreateInstanceInput = {
+    name: string;
+    description?: string;
+    org: string;
+    createdBy: string;        // current user id/descriptor
+    owners?: string[];        // if omitted, default [createdBy]
+    projectTeamPairs: SelectedProjectType[];
+};

package/@danieli-automation/devops-plugin-core/src/core/types/instance/CrossSprintInstanceType.ts

@@ -0,0 +1,20 @@
+import { SelectedProjectType } from "core/types/SelectedProjectType";
+
+export type CrossSprintInstanceType = {
+    id: string;                      // GUID/UUID
+    name: string;
+    description?: string;
+
+    org: string;                     // dev.azure.com/{org}
+    createdBy: any;               // user identifier (UPN/email or descriptor)
+    owners: string[];                // list of JMs (can contain createdBy)
+
+    projectTeamPairs: SelectedProjectType[];  // N project/team pairs
+
+    createdAt: string;
+    updatedAt: string;
+
+    isDefault?: boolean;             // whether this instance is the default one for the whole TEAM
+};
+
+export type CrossSprintInstanceMap = Record<string, CrossSprintInstanceType>;

package/@danieli-automation/devops-plugin-core/src/core/types/instance/DefaultInstanceType.ts

@@ -0,0 +1,12 @@
+export type DefaultInstanceType = {
+    id?: string;                      // GUID/UUID
+    name?: string;
+    description?: string;
+
+    org?: string;                     // dev.azure.com/{org}
+    createdBy?: string;               // user identifier (UPN/email or descriptor)
+    owners?: string[];                // list of JMs (can contain createdBy)
+
+    createdAt?: string;
+    updatedAt?: string;
+}