@nexia/sdk 0.5.0

package/dist/resources/resource-projections.d.ts

@@ -0,0 +1,311 @@
+export interface ResourceProjectionReference {
+    app_key: string;
+    resource_key: string;
+    resource_id: string;
+    display: string;
+    route?: string | null;
+}
+export interface ResourceBoardCard {
+    resource: ResourceProjectionReference;
+    summary: ResourceBoardSummaryField[];
+    version: number;
+    allowed_actions: string[];
+}
+export interface ResourceBoardSummaryField {
+    key: string;
+    label: string;
+    value: string | number | boolean | null;
+}
+export interface ResourceBoardLane {
+    key: string;
+    label: string;
+    count: number;
+    accepted_actions: string[];
+    cards: ResourceBoardCard[];
+}
+export interface ResourceBoardProjection {
+    board_key: string;
+    version: number;
+    lanes: ResourceBoardLane[];
+    filters?: Record<string, unknown>;
+}
+export interface ResourceBoardMoveCommand {
+    resource: ResourceProjectionReference;
+    source_lane: string;
+    target_lane: string;
+    target_order: number;
+    action_key: string;
+    expected_version: number;
+    idempotency_key: string;
+}
+export type ResourceBoardMutationResult = {
+    accepted: true;
+    projection: ResourceBoardProjection;
+    version: number;
+    replayed?: boolean;
+} | {
+    accepted: false;
+    reason: string;
+};
+export type ResourceBoardLoadState = 'loading' | 'ready' | 'error';
+export interface ResourceBoardLabels {
+    board: string;
+    laneCount: (laneLabel: string, count: number) => string;
+    moveCard: (resourceDisplay: string) => string;
+    moveError: (reason: string) => string;
+}
+export interface ResourceBoardProps {
+    projection?: ResourceBoardProjection | null;
+    state: ResourceBoardLoadState;
+    labels: ResourceBoardLabels;
+    readOnly?: boolean;
+    partiallyAuthorized?: boolean;
+    onRetry?: () => void;
+    onMove?: (command: ResourceBoardMoveCommand) => Promise<ResourceBoardMutationResult>;
+    onOpenResource?: (resource: ResourceProjectionReference) => void;
+}
+export type NxCalendarInteraction = 'reschedule' | 'resize';
+export interface NxCalendarActionBinding {
+    interaction: NxCalendarInteraction;
+    action_key: string;
+}
+interface NxCalendarOccurrenceBase {
+    source_key: string;
+    app_key: string;
+    occurrence_id: string;
+    source_revision: string;
+    resource: ResourceProjectionReference | null;
+    title: string;
+    status?: string | null;
+    category?: string | null;
+    color_token?: string | null;
+    recurrence_id?: string | null;
+    exception_id?: string | null;
+    allowed_actions: NxCalendarActionBinding[];
+    owner_route?: string | null;
+    redacted?: boolean;
+}
+export type NxCalendarTemporalRange = {
+    start: string;
+    end: string;
+    all_day: true;
+    timezone: string;
+} | {
+    start: string;
+    end: string;
+    all_day: false;
+    timezone: string;
+};
+export type NxCalendarOccurrence = NxCalendarOccurrenceBase & NxCalendarTemporalRange;
+/** User-selected empty calendar range, suitable for pre-filling a create form. */
+export type NxCalendarSelection = NxCalendarTemporalRange;
+export interface NxCalendarRange {
+    /** Floating calendar-local ISO date/time without a UTC or offset suffix. */
+    start: string;
+    /** Floating calendar-local ISO date/time without a UTC or offset suffix. */
+    end: string;
+    timezone: string;
+}
+interface NxCalendarActionCommandBase {
+    source_key: string;
+    resource: ResourceProjectionReference;
+    occurrence_id: string;
+    recurrence_id?: string | null;
+    exception_id?: string | null;
+    interaction: NxCalendarInteraction;
+    action_key: string;
+    expected_source_revision: string;
+    idempotency_key: string;
+}
+export type NxCalendarActionCommand = NxCalendarActionCommandBase & NxCalendarTemporalRange;
+export type NxCalendarActionResult = {
+    accepted: true;
+    occurrence: NxCalendarOccurrence;
+    reason?: null;
+} | {
+    accepted: false;
+    occurrence?: null;
+    reason: string;
+};
+export type NxCalendarView = 'dayGridMonth' | 'timeGridWeek' | 'timeGridDay' | 'listWeek';
+export interface NxCalendarProps {
+    occurrences: NxCalendarOccurrence[];
+    timezone: string;
+    locale: string;
+    initialView?: NxCalendarView;
+    loading?: boolean;
+    error?: boolean;
+    readOnly?: boolean;
+    fill?: boolean;
+    /** Renders occurrences as simple text controls instead of filled event bands. */
+    eventAppearance?: 'default' | 'text';
+    /** Keeps the calendar grid visible without a separate empty-state notice. */
+    showEmptyState?: boolean;
+    loadingLabel: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    errorTitle: string;
+    errorDescription: string;
+    readOnlyDescription: string;
+    retryLabel: string;
+    actionErrorMessage: (reason: string) => string;
+    keyboardInstructions: string;
+    onRangeChange?: (range: NxCalendarRange) => void;
+    onSelectRange?: (selection: NxCalendarSelection) => void;
+    onRetry?: () => void;
+    onOpenResource?: (occurrence: NxCalendarOccurrence) => void;
+    /** Opens an occurrence even when it does not represent a Resource. */
+    onOpenOccurrence?: (occurrence: NxCalendarOccurrence) => void;
+    onAction?: (command: NxCalendarActionCommand) => Promise<NxCalendarActionResult>;
+    createIdempotencyKey?: () => string;
+    'data-testid'?: string;
+}
+export type NxResourceSchedulerInteraction = NxCalendarInteraction | 'reassign';
+export interface NxResourceSchedulerActionBinding {
+    interaction: NxResourceSchedulerInteraction;
+    action_key: string;
+}
+export interface NxResourceSchedulerResource {
+    id: string;
+    label: string;
+    parent_id?: string | null;
+    color?: string | null;
+    metadata?: Record<string, unknown>;
+}
+export type NxResourceSchedulerOccurrence = Omit<NxCalendarOccurrence, 'allowed_actions'> & {
+    resource_ids: string[];
+    allowed_actions: NxResourceSchedulerActionBinding[];
+};
+/** Empty scheduler range selected by the user, including its resource lane. */
+export type NxResourceSchedulerSelection = NxCalendarSelection & {
+    resource_ids: string[];
+};
+export type NxResourceSchedulerActionCommand = Omit<NxCalendarActionCommand, 'interaction' | 'action_key'> & {
+    interaction: NxResourceSchedulerInteraction;
+    action_key: string;
+    resource_ids: string[];
+};
+export type NxResourceSchedulerActionResult = {
+    accepted: true;
+    occurrence: NxResourceSchedulerOccurrence;
+    reason?: null;
+} | {
+    accepted: false;
+    occurrence?: null;
+    reason: string;
+};
+export type NxResourceSchedulerView = 'resourceTimeGridDay' | 'resourceTimeGridWeek' | 'resourceTimelineDay' | 'resourceTimelineWeek' | 'resourceTimelineMonth';
+export interface NxResourceSchedulerProps {
+    resources: NxResourceSchedulerResource[];
+    occurrences: NxResourceSchedulerOccurrence[];
+    timezone: string;
+    locale: string;
+    initialView?: NxResourceSchedulerView;
+    loading?: boolean;
+    error?: boolean;
+    readOnly?: boolean;
+    fill?: boolean;
+    loadingLabel: string;
+    emptyTitle: string;
+    emptyDescription: string;
+    errorTitle: string;
+    errorDescription: string;
+    readOnlyDescription: string;
+    retryLabel: string;
+    resourceAreaLabel: string;
+    actionErrorMessage: (reason: string) => string;
+    onRangeChange?: (range: NxCalendarRange) => void;
+    onSelectRange?: (selection: NxResourceSchedulerSelection) => void;
+    onRetry?: () => void;
+    onOpenResource?: (resource: NxResourceSchedulerResource) => void;
+    onOpenOccurrence?: (occurrence: NxResourceSchedulerOccurrence) => void;
+    onAction?: (command: NxResourceSchedulerActionCommand) => Promise<NxResourceSchedulerActionResult>;
+    createIdempotencyKey?: () => string;
+    'data-testid'?: string;
+}
+export type ResourceScheduleView = 'gantt' | 'schedule-timeline';
+export type ResourceScheduleLoadState = 'loading' | 'ready' | 'error';
+export type ResourceScheduleDateSemantics = 'date_only' | 'timed';
+export type ResourceScheduleItemType = 'task' | 'milestone';
+export type ResourceScheduleDependencyType = 'finish_to_start' | 'start_to_start' | 'finish_to_finish' | 'start_to_finish';
+export type ResourceScheduleInteraction = 'reschedule' | 'create_dependency' | 'delete_dependency';
+export type ResourceScheduleTimeUnit = 'day' | 'minute';
+export interface ResourceScheduleActionBinding {
+    interaction: ResourceScheduleInteraction;
+    action_key: string;
+}
+export interface ResourceScheduleDatePair {
+    start: string;
+    end: string;
+}
+export interface ResourceScheduleItem {
+    resource: ResourceProjectionReference;
+    type: ResourceScheduleItemType;
+    date_semantics: ResourceScheduleDateSemantics;
+    start: string;
+    end: string;
+    duration: number;
+    duration_unit: ResourceScheduleTimeUnit;
+    progress: number;
+    version: string;
+    allowed_actions: ResourceScheduleActionBinding[];
+    parent?: ResourceProjectionReference | null;
+    group?: ResourceProjectionReference | null;
+    baseline?: ResourceScheduleDatePair | null;
+    actual?: ResourceScheduleDatePair | null;
+    work_calendar_reference?: string | null;
+    owner_route?: string | null;
+}
+export interface ResourceScheduleDependency {
+    id: string;
+    source: ResourceProjectionReference;
+    target: ResourceProjectionReference;
+    type: ResourceScheduleDependencyType;
+    lag: number;
+    lag_unit: ResourceScheduleTimeUnit;
+}
+export interface ResourceScheduleProjection {
+    schedule_key: string;
+    revision: string;
+    items: ResourceScheduleItem[];
+    dependencies: ResourceScheduleDependency[];
+}
+interface ResourceScheduleActionCommandBase {
+    schedule_key: string;
+    resource: ResourceProjectionReference;
+    interaction: ResourceScheduleInteraction;
+    action_key: string;
+    expected_projection_revision: string;
+    expected_resource_version: string;
+    idempotency_key: string;
+}
+export type ResourceScheduleActionCommand = (ResourceScheduleActionCommandBase & {
+    interaction: 'reschedule';
+    start: string;
+    end: string;
+    date_semantics: ResourceScheduleDateSemantics;
+}) | (ResourceScheduleActionCommandBase & {
+    interaction: 'create_dependency' | 'delete_dependency';
+    dependency: ResourceScheduleDependency;
+});
+export interface ResourceScheduleMutationResult {
+    accepted: boolean;
+    projection: ResourceScheduleProjection;
+    reason?: string | null;
+    replayed?: boolean;
+}
+export interface ResourceScheduleProps {
+    projection?: ResourceScheduleProjection | null;
+    state: ResourceScheduleLoadState;
+    view?: ResourceScheduleView;
+    fill?: boolean;
+    readOnly?: boolean;
+    partiallyAuthorized?: boolean;
+    onRetry?: () => void;
+    onAction?: (command: ResourceScheduleActionCommand) => Promise<ResourceScheduleMutationResult>;
+    /** Opens the caller-owned creation flow from the schedule's native add affordance. */
+    onCreateResource?: (parent?: ResourceProjectionReference) => void;
+    onOpenResource?: (resource: ResourceProjectionReference) => void;
+    createIdempotencyKey?: () => string;
+}
+export {};

package/dist/resources/resource-projections.js

@@ -0,0 +1 @@
+export {};

package/dist/resources/resource-transfer.d.ts

@@ -0,0 +1,208 @@
+import type { ReactNode } from "react";
+import type { ResourceCreateContinuationTarget } from "../shell";
+/** Lifecycle states returned by resource import endpoints. */
+export type ResourceImportRunStatus = "queued" | "processing" | "completed" | "completed_with_errors" | "failed";
+export type ResourceTransferFormat = "csv" | "xlsx" | "txt" | "json" | string;
+export interface ResourceTransferMessage {
+    key: string;
+    params?: Record<string, string | number>;
+}
+/** Transfer capabilities published as `meta.resource_transfer`. */
+export interface ResourceTransferMeta {
+    resource_key: string;
+    schema: {
+        columns: Array<{
+            key: string;
+            label: string;
+            type: string;
+            required: boolean;
+            importable: boolean;
+            exportable: boolean;
+            unique_import_key: boolean;
+            export_sensitive?: boolean;
+            export_requires_purpose?: boolean;
+            export_requires_fresh_authentication?: boolean;
+        }>;
+    };
+    schema_hash: string;
+    formats: ResourceTransferFormat[];
+    export_formats?: ResourceTransferFormat[];
+    import_formats?: ResourceTransferFormat[];
+    row_limits: {
+        export: number;
+        import: number;
+    };
+    actions: {
+        export: string;
+        /** Queue-first export endpoint. Absent on older hosts. */
+        export_start?: string;
+        template: string;
+        preview: string;
+        import: string;
+    };
+    allowed: {
+        export: boolean;
+        import: boolean;
+    };
+    export_context?: {
+        title: string;
+        items: Array<{
+            label: string;
+            value: string | number;
+            value_label?: string;
+        }>;
+    };
+}
+export interface ResourceImportPreviewRow {
+    line: number;
+    values: Record<string, string | null>;
+    errors: ResourceTransferMessage[];
+}
+export interface ResourceImportPreview {
+    format: string;
+    total_rows: number;
+    file_headers: string[];
+    headers: {
+        unknown: string[];
+        missing: string[];
+    };
+    columns: Array<{
+        key: string;
+        label: string;
+        required: boolean;
+        unique_import_key: boolean;
+    }>;
+    preview_rows: ResourceImportPreviewRow[];
+}
+export interface ResourceImportSummary {
+    rows: number;
+    created: number;
+    skipped: number;
+    errors: number;
+    error_rows?: Array<{
+        row: number;
+        errors: ResourceTransferMessage[];
+    }>;
+    message?: ResourceTransferMessage;
+}
+export interface ResourceImportRun {
+    id: number;
+    resource_key: string;
+    direction: string;
+    format: string;
+    status: ResourceImportRunStatus;
+    status_url: string;
+}
+export interface ResourceImportResponse {
+    run: ResourceImportRun;
+    summary: ResourceImportSummary | null;
+}
+/**
+ * Host-owned import workflow that Apps may embed in a management workspace.
+ *
+ * Apps provide only the authorized endpoint descriptors and refresh callback;
+ * upload intents, parsing, preview, polling, and result chrome remain owned by
+ * Core. This is intentionally the same workflow used by generated Resource
+ * lists so an App must not rebuild spreadsheet handling locally.
+ */
+export interface NxResourceImportDialogProps {
+    open: boolean;
+    onClose: () => void;
+    previewUrl: string;
+    importUrl: string;
+    templateUrl: string;
+    formats?: string[];
+    onImported: () => void | Promise<void>;
+    translationPrefix?: string;
+    testIdPrefix?: string;
+}
+/** Host-owned Resource Transfer actions for list and management surfaces. */
+export interface NxResourceTransferActionsProps {
+    transferMeta: ResourceTransferMeta | null | undefined;
+    onImported: () => void | Promise<void>;
+    translationPrefix?: string;
+    testIdPrefix?: string;
+}
+export interface DatasetImportConfirmationSummary {
+    resourceKey: string;
+    totalRows: number;
+    willCreate: number;
+    willUpdate: number;
+    willReject: number;
+}
+/** Shared mapped-dataset import workspace for App management destinations. */
+export interface NxDatasetImportWorkspaceProps {
+    sourceProfileKey?: string;
+    showSourceSelector?: boolean;
+    resourceKey: string;
+    /** App-owned reference review above the shared editable preview. */
+    renderReferenceReview?: (context: {
+        rows: Array<{
+            line: number;
+            values: Record<string, string | null>;
+            issues?: Array<{
+                kind: string;
+                field: string;
+                value: string;
+                reference_kind?: string;
+                reference_value?: string;
+                label_key?: string;
+                message_key?: string;
+            }>;
+        }>;
+        busy: boolean;
+        recheck: () => void;
+        /** Open an offered reference editor after preserving the import draft. */
+        createReference: (kind: string, seed: string) => void;
+        /** Apply edits to source rows and rerun the existing validation pipeline. */
+        applyChanges: (changes: Record<string, Record<string, string | null>>) => Promise<void>;
+    }) => ReactNode;
+    /** Allowed display values, keyed by import column. Domain lookup remains App-owned. */
+    cellOptions?: Record<string, string[]>;
+    inlineEditing?: boolean;
+    onCompleted?: (result: Record<string, unknown>) => void | Promise<void>;
+    /** Called when an ordinary Resource Transfer import has been accepted by the queue. */
+    onQueued?: (operation: {
+        ticket: string;
+        statusUrl: string;
+    }) => void | Promise<void>;
+    /** Hide the dataset name and generic import help when the containing page already supplies them. */
+    showHeader?: boolean;
+    /** Render template downloads in the standard overflow menu used by list toolbars. */
+    templateMenuVariant?: "button" | "overflow";
+    /** Return to the upload-only state after a completed ticket reports zero row errors. */
+    resetOnSuccessfulCompletion?: boolean;
+    /** App-owned copy shown on the primary button while the commit is running. */
+    processingLabel?: string;
+    /** App-owned title for domain-specific apply semantics; Core supplies only counts. */
+    confirmationTitle?: (summary: DatasetImportConfirmationSummary) => string;
+    testIdPrefix?: string;
+    /** App-owned canonical create actions for reference issues reported by its pipeline. */
+    referenceCreateActions?: Record<string, {
+        label: string;
+        onCreate: (seed: string) => void;
+        continuation: ResourceCreateContinuationTarget;
+    }>;
+    /** Keep stable App-owned decisions while a contextual reference create is completed and rechecked. */
+    preserveDecisionsOnReferenceRefresh?: boolean;
+    /** Drop submitted decisions that the refreshed App plan no longer offers. */
+    retainOnlyOfferedDecisions?: boolean;
+}
+/** Shared export workspace for an App-contributed dataset. */
+export interface NxDatasetExportWorkspaceProps {
+    resourceKey: string;
+    legalEntityPublicId?: string | null;
+    operatingUnitPublicId?: string | null;
+    asOf?: string | null;
+    testIdPrefix?: string;
+    /** Render the export action as a standard overflow menu in compact action areas. */
+    triggerVariant?: "button" | "overflow";
+    /** App-owned actions appended to the same overflow menu as export. */
+    overflowItems?: Array<{
+        id: string;
+        label: string;
+        disabled?: boolean;
+        testId?: string;
+        onSelect: () => void;
+    }>;
+}

package/dist/resources/resource-transfer.js

@@ -0,0 +1 @@
+export {};