import { IUiPath } from '../core/index';

/**
 * Simplified universal pagination cursor
 * Used to fetch next/previous pages
 */
interface PaginationCursor {
    /** Opaque string containing all information needed to fetch next page */
    value: string;
}
/**
 * Discriminated union for pagination methods - ensures cursor and jumpToPage are mutually exclusive
 */
type PaginationMethodUnion = {
    cursor?: PaginationCursor;
    jumpToPage?: never;
} | {
    cursor?: never;
    jumpToPage?: number;
} | {
    cursor?: never;
    jumpToPage?: never;
};
/**
 * Pagination options. Users cannot specify both cursor and jumpToPage.
 */
type PaginationOptions = {
    /** Size of the page to fetch (items per page) */
    pageSize?: number;
} & PaginationMethodUnion;
/**
 * Paginated response containing items and navigation information
 */
interface PaginatedResponse<T> {
    /** The items in the current page */
    items: T[];
    /** Total count of items across all pages (if available) */
    totalCount?: number;
    /** Whether more pages are available */
    hasNextPage: boolean;
    /** Cursor to fetch the next page (if available) */
    nextCursor?: PaginationCursor;
    /** Cursor to fetch the previous page (if available) */
    previousCursor?: PaginationCursor;
    /** Current page number (1-based, if available) */
    currentPage?: number;
    /** Total number of pages (if available) */
    totalPages?: number;
    /** Whether this pagination type supports jumping to arbitrary pages */
    supportsPageJump: boolean;
}
/**
 * Response for non-paginated calls that includes both data and total count
 */
interface NonPaginatedResponse<T> {
    items: T[];
    totalCount?: number;
}
/**
 * Helper type for defining paginated method overloads
 * Creates a union type of all ways pagination can be triggered
 */
type HasPaginationOptions<T> = (T & {
    pageSize: number;
}) | (T & {
    cursor: PaginationCursor;
}) | (T & {
    jumpToPage: number;
});

/**
 * Pagination types supported by the SDK
 */
declare enum PaginationType {
    OFFSET = "offset",
    TOKEN = "token"
}
/**
 * Interface for service access methods needed by pagination helpers
 */
interface PaginationServiceAccess {
    get<T>(path: string, options?: any): Promise<{
        data: T;
    }>;
    post<T>(path: string, body?: any, options?: any): Promise<{
        data: T;
    }>;
    requestWithPagination<T>(method: string, path: string, paginationOptions: PaginationOptions, options: RequestWithPaginationOptions): Promise<PaginatedResponse<T>>;
}
/**
 * Field names for extracting data from paginated responses.
 */
interface PaginationFieldNames {
    itemsField?: string;
    totalCountField?: string;
    continuationTokenField?: string;
}
/**
 * Options for the requestWithPagination method in BaseService.
 */
interface RequestWithPaginationOptions extends RequestSpec {
    pagination: PaginationFieldNames & {
        paginationType: PaginationType;
        paginationParams?: {
            pageSizeParam?: string;
            offsetParam?: string;
            tokenParam?: string;
            countParam?: string;
            convertToSkip?: boolean;
            zeroBased?: boolean;
        };
    };
}

/**
 * HTTP methods supported by the API client
 */
type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
/**
 * Supported response types for API requests
 */
type ResponseType = 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream';
/**
 * Query parameters type with support for arrays and nested objects
 */
type QueryParams = Record<string, string | number | boolean | Array<string | number | boolean> | null | undefined>;
/**
 * Standard HTTP headers type
 */
type Headers = Record<string, string>;
/**
 * Options for request retries
 */
interface RetryOptions {
    /** Maximum number of retry attempts */
    maxRetries?: number;
    /** Base delay between retries in milliseconds */
    retryDelay?: number;
    /** Whether to use exponential backoff */
    useExponentialBackoff?: boolean;
    /** Status codes that should trigger a retry */
    retryableStatusCodes?: number[];
}
/**
 * Options for request timeouts
 */
interface TimeoutOptions {
    /** Request timeout in milliseconds */
    timeout?: number;
    /** Whether to abort the request on timeout */
    abortOnTimeout?: boolean;
}
/**
 * Options for request body transformation
 */
interface BodyOptions {
    /** Whether to stringify the body */
    stringify?: boolean;
    /** Content type override */
    contentType?: string;
}
/**
 * Pagination metadata for API requests
 */
interface PaginationMetadata {
    /** Type of pagination used by the API endpoint */
    paginationType: PaginationType;
    /** Response field containing items array (defaults to 'value') */
    itemsField?: string;
    /** Response field containing total count (defaults to '@odata.count') */
    totalCountField?: string;
    /** Response field containing continuation token (defaults to 'continuationToken') */
    continuationTokenField?: string;
}
/**
 * Base interface for all API requests
 */
interface RequestSpec {
    /** HTTP method for the request */
    method?: HttpMethod;
    /** URL endpoint for the request */
    url?: string;
    /** Query parameters to be appended to the URL */
    params?: QueryParams;
    /** HTTP headers to include with the request */
    headers?: Headers;
    /** Raw body content (takes precedence over data) */
    body?: unknown;
    /** Expected response type */
    responseType?: ResponseType;
    /** Request timeout options */
    timeoutOptions?: TimeoutOptions;
    /** Retry behavior options */
    retryOptions?: RetryOptions;
    /** Body transformation options */
    bodyOptions?: BodyOptions;
    /** AbortSignal for cancelling the request */
    signal?: AbortSignal;
    /** Pagination metadata for the request */
    pagination?: PaginationMetadata;
}

interface ApiResponse<T> {
    data: T;
}
/**
 * Base class for all UiPath SDK services.
 *
 * Provides common functionality for authentication, configuration, and API communication.
 * All service classes extend this base to inherit dependency injection and HTTP client access.
 *
 * This class implements the dependency injection pattern where services receive a configured
 * UiPath instance. The ApiClient is created internally and handles all HTTP operations
 * including authentication token management.
 *
 * @remarks
 * Service classes should extend this base and call `super(uiPath)` in their constructor.
 * Protected HTTP methods (get, post, put, patch, delete) are available to all subclasses.
 *
 */
declare class BaseService {
    #private;
    /**
     * SDK configuration (read-only). Available to subclasses so they can
     * fall back to init-time defaults like `folderKey`.
     */
    protected readonly config: {
        folderKey?: string;
    };
    /**
     * Creates a base service instance with dependency injection.
     *
     * Extracts configuration, execution context, and token manager from the UiPath instance
     * to initialize an authenticated API client. The ApiClient handles all HTTP operations
     * and token management internally.
     *
     * @param instance - UiPath SDK instance providing authentication and configuration.
     *                    Services receive this via dependency injection in the modular pattern.
     * @param headers - Optional default headers to include in every request (e.g. `x-uipath-external-user-id` for
     *                  CAS external-app auth)
     *
     * @example
     * ```typescript
     * // Services automatically call this via super()
     * export class EntityService extends BaseService {
     *   constructor(instance: IUiPath) {
     *     super(instance); // Initializes the internal ApiClient
     *   }
     * }
     *
     * // Usage in modular pattern
     * import { UiPath } from '@uipath/uipath-typescript/core';
     * import { Entities } from '@uipath/uipath-typescript/entities';
     *
     * const sdk = new UiPath(config);
     * await sdk.initialize();
     * const entities = new Entities(sdk);
     * ```
     */
    constructor(instance: IUiPath, headers?: Record<string, string>);
    /**
     * Gets a valid authentication token, refreshing if necessary.
     * Use this when you need to manually add Authorization headers (e.g., direct uploads).
     *
     * @returns Promise resolving to a valid access token string
     * @throws AuthenticationError if no token is available or refresh fails
     */
    protected getValidAuthToken(): Promise<string>;
    /**
     * Creates a service accessor for pagination helpers
     * This allows pagination helpers to access protected methods without making them public
     */
    protected createPaginationServiceAccess(): PaginationServiceAccess;
    protected request<T>(method: string, path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
    protected requestWithSpec<T>(spec: RequestSpec): Promise<ApiResponse<T>>;
    protected get<T>(path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
    protected post<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
    protected put<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
    protected patch<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
    protected delete<T>(path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
    /**
     * Execute a request with cursor-based pagination
     */
    protected requestWithPagination<T>(method: string, path: string, paginationOptions: PaginationOptions, options: RequestWithPaginationOptions): Promise<PaginatedResponse<T>>;
    /**
     * Validates and prepares pagination parameters from options
     */
    private validateAndPreparePaginationParams;
    /**
     * Prepares request parameters for pagination based on pagination type
     */
    private preparePaginationRequestParams;
    /**
     * Creates a paginated response from API response
     */
    private createPaginatedResponseFromResponse;
    /**
     * Determines if there are more pages based on pagination type and metadata
     */
    private determineHasMorePages;
}

/**
 * Standardized result interface for all operation methods (pause, cancel, complete, update, upload, etc.)
 * Success responses include data from the request context or API response
 */
interface OperationResponse<TData> {
    /**
     * Whether the operation was successful
     */
    success: boolean;
    /**
     * Response data (can contain error details in case of failure)
     */
    data: TData;
}

/**
 * Notification inbox types — raw API shapes and request/response options.
 */

/**
 * Priority level assigned to a notification by the publisher.
 */
declare enum NotificationPriority {
    Low = "Low",
    Medium = "Medium",
    High = "High",
    Critical = "Critical"
}
/**
 * Severity classification of a notification topic.
 */
declare enum NotificationCategory {
    /** Informational — no action required. */
    Info = "Info",
    /** Successful operation completed. */
    Success = "Success",
    /** Warning — degraded behaviour or non-fatal issue. */
    Warn = "Warn",
    /** Error — operation failed but the system continues. */
    Error = "Error",
    /** Fatal — unrecoverable failure. */
    Fatal = "Fatal"
}
/**
 * Notification delivery channel.
 *
 * `InApp` is always implicitly enabled (it is not returned by `getSupportedChannels()`);
 * the others must be checked via `Subscriptions.getSupportedChannels()`.
 */
declare enum NotificationMode {
    /** Real-time in-app push. Always available. */
    InApp = "InApp",
    /** Email delivery. */
    Email = "Email",
    /** Slack delivery. */
    Slack = "Slack",
    /** Microsoft Teams delivery. */
    Teams = "Teams"
}
/**
 * Notification entry as returned by `GET /odata/v1/NotificationEntry`.
 *
 * Field selection: many internal/transport-layer fields (`partitionKey`, `correlationId`,
 * `publicationId`, `messageVersion`, `messageTemplateKey`, `serviceRegistryName`,
 * `entityOrgName`, `entityTenantName`) are returned by the API but dropped from the SDK
 * because they have no use for an application developer.
 */
interface NotificationGetResponse {
    /** Notification GUID. */
    id: string;
    /** Resolved notification message text. */
    message: string | null;
    /** Whether the user has read this notification. */
    hasRead: boolean;
    /** Name of the publisher (e.g. `Orchestrator`, `Actions`). */
    publisherName: string;
    /** Publisher GUID. */
    publisherId: string;
    /** Human-readable topic name. */
    topicName: string;
    /** Stable topic identifier (e.g. `Process.JobExecution.Faulted`). */
    topicKeyName: string;
    /** Topic GUID. */
    topicId: string;
    /** GUID of the user this notification belongs to (returned uppercase by the API). */
    userId: string;
    /** Email of the user. Often `null`. */
    userEmail: string | null;
    /** Tenant GUID this notification belongs to. Often `null` for org-scoped notifications. */
    tenantId: string | null;
    /** Notification priority. */
    priority: NotificationPriority;
    /** Notification severity category. */
    category: NotificationCategory;
    /** JSON string of template parameters — parse with `JSON.parse()`. May be `null`. */
    messageParam: string | null;
    /** URL to navigate to when the notification is clicked. */
    redirectionUrl: string | null;
    /** Unix epoch **seconds** when the notification was published. */
    publishedOn: number;
}
/**
 * Options for `Notifications.getAll()`.
 *
 * Supports OData query options (`filter`, `orderby`) and SDK cursor pagination.
 *
 * Notes:
 * - `$select` and `$expand` are not exposed because the API returns 500 on `$select`
 *   and there are no expandable relationships on this endpoint.
 */
type NotificationGetAllOptions = PaginationOptions & {
    filter?: string;
    orderby?: string;
};
/**
 * Response from `markAsRead()` / `markAsUnread()`.
 *
 * `notificationIds` echoes the IDs that were marked; `read` reflects the new state.
 */
type NotificationUpdateReadResponse = OperationResponse<{
    notificationIds: string[];
    read: boolean;
}>;
/**
 * Response from `markAllAsRead()`.
 */
type NotificationMarkAllReadResponse = OperationResponse<{
    all: true;
    read: true;
}>;
/**
 * Response from `deleteByIds()`.
 *
 * `notificationIds` echoes the IDs that were deleted.
 */
type NotificationDeleteResponse = OperationResponse<{
    notificationIds: string[];
}>;
/**
 * Response from `deleteAll()`.
 */
type NotificationDeleteAllResponse = OperationResponse<{
    all: true;
}>;

/**
 * Notification service model — public response shapes and the ServiceModel interface
 * that drives generated API documentation.
 */

/**
 * Public surface of the Notifications service. JSDoc on this interface drives
 * the generated API reference documentation.
 *
 * Every method takes the tenant GUID as the first argument — the notification
 * API identifies the acting tenant via the `X-UIPATH-Internal-TenantId` header
 * and the SDK forwards `tenantId` into that header on each call.
 */
interface NotificationServiceModel {
    /**
     * Lists notifications from the current user's inbox.
     *
     * Returns the full list when no pagination params are provided, or a paginated cursor result
     * when any of `pageSize`/`cursor`/`jumpToPage` is supplied. Supports OData `filter` and
     * `orderby` query options.
     *
     * @param tenantId - Tenant GUID
     * @param options - Optional OData query and pagination options
     * @returns Promise resolving to either a {@link NonPaginatedResponse}<{@link NotificationGetResponse}> or a {@link PaginatedResponse}<{@link NotificationGetResponse}> when pagination options are used.
     *
     * @example Basic usage
     * ```typescript
     * import { Notifications } from '@uipath/uipath-typescript/notifications';
     *
     * const notifications = new Notifications(sdk);
     * const all = await notifications.getAll('<tenantId>');
     * ```
     *
     * @example Filter unread, most recent first
     * ```typescript
     * const unread = await notifications.getAll('<tenantId>', {
     *   filter: 'hasRead eq false',
     *   orderby: 'publishedOn desc',
     * });
     * ```
     *
     * @example First page with pagination
     * ```typescript
     * const page1 = await notifications.getAll('<tenantId>', { pageSize: 20 });
     * if (page1.hasNextPage) {
     *   const page2 = await notifications.getAll('<tenantId>', { cursor: page1.nextCursor });
     * }
     * ```
     * @internal
     */
    getAll<T extends NotificationGetAllOptions = NotificationGetAllOptions>(tenantId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<NotificationGetResponse> : NonPaginatedResponse<NotificationGetResponse>>;
    /**
     * Marks the given notifications as read.
     *
     * @param tenantId - Tenant GUID
     * @param notificationIds - GUIDs of notifications to mark read
     * @returns Operation result echoing the affected IDs and new read state
     * {@link NotificationUpdateReadResponse}
     *
     * @example
     * ```typescript
     * await notifications.markAsRead('<tenantId>', ['<notificationId-1>', '<notificationId-2>']);
     * ```
     * @internal
     */
    markAsRead(tenantId: string, notificationIds: string[]): Promise<NotificationUpdateReadResponse>;
    /**
     * Marks the given notifications as unread.
     *
     * @param tenantId - Tenant GUID
     * @param notificationIds - GUIDs of notifications to mark unread
     * @returns Operation result echoing the affected IDs and new read state
     * {@link NotificationUpdateReadResponse}
     *
     * @example
     * ```typescript
     * await notifications.markAsUnread('<tenantId>', ['<notificationId>']);
     * ```
     * @internal
     */
    markAsUnread(tenantId: string, notificationIds: string[]): Promise<NotificationUpdateReadResponse>;
    /**
     * Marks all notifications in the current user's inbox as read.
     *
     * @param tenantId - Tenant GUID
     * @returns Operation result confirming the bulk update
     * {@link NotificationMarkAllReadResponse}
     *
     * @example
     * ```typescript
     * await notifications.markAllAsRead('<tenantId>');
     * ```
     * @internal
     */
    markAllAsRead(tenantId: string): Promise<NotificationMarkAllReadResponse>;
    /**
     * Deletes the given notifications.
     *
     * @param tenantId - Tenant GUID
     * @param notificationIds - GUIDs of notifications to delete. Must be non-empty.
     * @returns Operation result echoing the deleted IDs
     * {@link NotificationDeleteResponse}
     *
     * @example
     * ```typescript
     * await notifications.deleteByIds('<tenantId>', ['<notificationId-1>', '<notificationId-2>']);
     * ```
     * @internal
     */
    deleteByIds(tenantId: string, notificationIds: string[]): Promise<NotificationDeleteResponse>;
    /**
     * Deletes all notifications from the current user's inbox.
     *
     * @param tenantId - Tenant GUID
     * @returns Operation result confirming the bulk delete
     * {@link NotificationDeleteAllResponse}
     *
     * @example
     * ```typescript
     * await notifications.deleteAll('<tenantId>');
     * ```
     * @internal
     */
    deleteAll(tenantId: string): Promise<NotificationDeleteAllResponse>;
}

/**
 * NotificationService — manages the current user's notification inbox.
 */

/**
 * Service for interacting with the UiPath Notification inbox.
 *
 * Provides inbox operations against the current user's notifications (the
 * `/odata/v1/NotificationEntry` API).
 *
 * Every public method takes the acting tenant GUID as the first argument — the
 * notification API identifies the tenant via the `X-UIPATH-Internal-TenantId`
 * header and the SDK forwards `tenantId` into that header on each call.
 */
declare class NotificationService extends BaseService implements NotificationServiceModel {
    getAll<T extends NotificationGetAllOptions = NotificationGetAllOptions>(tenantId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<NotificationGetResponse> : NonPaginatedResponse<NotificationGetResponse>>;
    markAsRead(tenantId: string, notificationIds: string[]): Promise<NotificationUpdateReadResponse>;
    markAsUnread(tenantId: string, notificationIds: string[]): Promise<NotificationUpdateReadResponse>;
    markAllAsRead(tenantId: string): Promise<NotificationMarkAllReadResponse>;
    deleteByIds(tenantId: string, notificationIds: string[]): Promise<NotificationDeleteResponse>;
    deleteAll(tenantId: string): Promise<NotificationDeleteAllResponse>;
    private updateRead;
}

/**
 * Subscription service types — request/response shapes for user subscription preferences.
 */

/**
 * Status of a notification mode (channel) for a publisher — whether the user has
 * activated this channel.
 */
interface AllowedMode {
    /** Notification channel. */
    name: NotificationMode;
    /** Whether the user has activated this channel for the publisher. */
    isActive: boolean;
}
/**
 * Per-mode subscription state for a topic.
 */
interface SubscriptionMode {
    /** Notification channel. */
    name: NotificationMode;
    /** Whether the user is subscribed to this topic via this channel. */
    isSubscribed: boolean;
    /** Whether the topic is subscribed by default via this channel. */
    isSubscribedByDefault: boolean;
}
/**
 * Base topic shape — identity/discovery fields only, with no subscription state.
 */
interface SubscriptionTopicBase {
    /** Topic GUID. */
    id: string;
    /** Stable topic identifier (e.g. `Process.JobExecution.Faulted`). */
    name: string;
    /** Human-readable topic name. */
    displayName: string | null;
    /** Topic description. */
    description: string | null;
    /** Topic group name. */
    group: string | null;
}
/**
 * A topic that the user can subscribe to, with full subscription state — as returned by `getAll()`.
 */
interface SubscriptionTopic extends SubscriptionTopicBase {
    /** Severity category. */
    category: NotificationCategory;
    /** Parent topic group name. Often `null`. */
    parentGroup: string | null;
    /** Whether the user is currently subscribed to this topic. */
    isSubscribed: boolean;
    /** Whether the topic is mandatory — cannot be unsubscribed. */
    isMandatory: boolean;
    /** Whether the topic should be visible in the user-facing subscription UI. */
    isVisible: boolean;
    /** Whether the topic is subscribed by default for new users. */
    isDefault: boolean;
    /** Whether notifications for this topic can be batched. */
    isAllowedToBeDispatchedInBatch: boolean;
    /** Whether the topic is marked as infrequent (lower-priority delivery). */
    isInfrequent: boolean;
    /** Number of days notifications for this topic are retained. */
    retentionDays: number;
    /** Display ordering hint. */
    orderingSequence: number;
    /** Per-channel subscription state. */
    modes: SubscriptionMode[];
}
/**
 * An entity reference used in publisher / topic-group subscription requests.
 */
interface SubscriptionEntity {
    /** Entity GUID. */
    id: string;
    /** Entity name. */
    name: string | null;
    /** Entity type. */
    type: string | null;
    /** Parent name (e.g. folder name for a sub-folder). */
    parentName: string | null;
    /** Whether the user is subscribed to notifications for this entity. */
    isSubscribed: boolean;
}
/**
 * Group of entities that belong to a topic group.
 */
interface TopicGroupEntity {
    /** Topic group name. */
    name: string | null;
    /** Entities belonging to this group. */
    entities: SubscriptionEntity[] | null;
}
/**
 * Entity-sync operation an event maps to.
 */
declare enum EntitySyncOperation {
    Add = "Add",
    Delete = "Delete"
}
/**
 * Event mapping that triggers entity synchronization for an entity type.
 */
interface EntitySyncEvent {
    /** Source event name. */
    eventName: string | null;
    /** Sync operation the event maps to. */
    operation: EntitySyncOperation;
}
/**
 * Entity-type metadata declared by a publisher (e.g. folder entity registration).
 */
interface SubscriptionEntityType {
    /** Entity type name. */
    type: string | null;
    /** URL template for resolving entity links. */
    urlTemplate: string | null;
    /** Property used to project the entity in publications. */
    projectionProperty: string | null;
    /** Publication payload property carrying the entity reference. */
    publicationPayloadProperty: string | null;
    /** Request type used for entity sync. */
    requestType: string | null;
    /** Payload template for entity sync requests. */
    payload: string | null;
    /** Events that trigger entity synchronization. */
    entitySyncEvents: EntitySyncEvent[] | null;
}
/**
 * Entity types supported by a topic group.
 */
interface TopicGroupEntityType {
    /** Topic group name. */
    name: string | null;
    /** Entity type names. */
    entityTypes: string[] | null;
}
/**
 * Base publisher shape — identity/discovery fields and the topic catalogue, with no subscription state.
 */
interface SubscriptionPublisherBase {
    /** Publisher GUID. */
    id: string;
    /** Stable publisher name (e.g. `Orchestrator`, `Actions`). */
    name: string;
    /** Human-readable publisher name. */
    displayName: string | null;
    /** Topics published under this publisher. */
    topics: SubscriptionTopicBase[];
}
/**
 * A publisher with its topics, channels, and subscription state — as returned by `getAll()`.
 */
interface SubscriptionPublisher extends SubscriptionPublisherBase {
    /** Topics published under this publisher, with full per-topic subscription state. */
    topics: SubscriptionTopic[];
    /** URL to navigate to when a publisher notification is clicked. */
    redirectionUrl: string | null;
    /** Number of days notifications from this publisher are retained. */
    retentionDays: number;
    /** Whether notifications from this publisher are included in summary digests. */
    addToSummary: boolean;
    /** Whether the user has opted in to receive notifications from this publisher. */
    isUserOptin: boolean;
    /** Channels available for this publisher and their activation state. */
    modes: AllowedMode[];
    /** Entities (e.g. folders) the user has entity-level subscriptions for. */
    entities: SubscriptionEntity[] | null;
    /** Entity types the publisher exposes. */
    entityTypes: SubscriptionEntityType[] | null;
    /** Topic-group entity sets the user has entity-level subscriptions for. */
    topicGroupEntities: TopicGroupEntity[];
    /** Topic-group entity types. */
    topicGroupEntityTypes: TopicGroupEntityType[] | null;
}
/**
 * Channel availability returned by `getSupportedChannels()`.
 *
 * Note: `InApp` is never returned — it is always implicitly available.
 */
interface SupportedChannel {
    /** Notification channel. */
    name: NotificationMode;
    /** Whether the channel is enabled for the current tenant. */
    isEnabled: boolean;
}
/**
 * Options for `Subscriptions.getAll()`.
 */
interface SubscriptionGetAllOptions {
    /** Filter to specific publisher names. When omitted, all publishers are returned. */
    publishers?: string[];
}
/**
 * Options for `Subscriptions.getPublishers()`.
 */
interface SubscriptionGetPublishersOptions {
    /** Filter to a specific publisher name. When omitted, all publishers are returned. */
    name?: string;
}
/**
 * Response from `getAll()` — publishers with their topics, channels, and full subscription state.
 */
interface SubscriptionGetResponse {
    /** Publishers with their topics and subscription state. */
    publishers: SubscriptionPublisher[];
}
/**
 * Response from `getPublishers()` — the publisher/topic discovery catalogue.
 *
 * Publishers and topics carry only identity/discovery fields (no subscription state);
 * use `getAll()` to inspect subscription state.
 */
interface SubscriptionGetPublishersResponse {
    /** Publishers with their topic catalogue. */
    publishers: SubscriptionPublisherBase[];
}
/**
 * Response from `getSupportedChannels()`.
 */
interface SubscriptionGetSupportedChannelsResponse {
    /** Notification channels supported in the current tenant. `InApp` is not listed — it is always available. */
    channels: SupportedChannel[];
}

/**
 * Subscription service model — public response shapes and the ServiceModel interface
 * that drives generated API documentation.
 */

/**
 * Public surface of the Subscriptions service. JSDoc on this interface drives
 * the generated API reference documentation.
 *
 * Every method takes the tenant GUID as the first argument, which the SDK
 * forwards to the subscription API on each call.
 */
interface SubscriptionServiceModel {
    /**
     * Gets the current user's subscription preferences, optionally filtered to a set of
     * publisher names.
     *
     * Returns the full list of publishers (their topics, channels, and current subscription
     * state) the user has access to. Use {@link SubscriptionGetAllOptions.publishers} to
     * narrow to specific publishers.
     *
     * @param tenantId - Tenant GUID
     * @param options - Optional publisher-name filter
     * @returns Full subscription state for the matched publishers
     * {@link SubscriptionGetResponse}
     *
     * @example Basic usage
     * ```typescript
     * import { Subscriptions } from '@uipath/uipath-typescript/notifications';
     *
     * const subscriptions = new Subscriptions(sdk);
     * const { publishers } = await subscriptions.getAll('<tenantId>');
     * ```
     *
     * @example Filter to specific publishers
     * ```typescript
     * const { publishers } = await subscriptions.getAll('<tenantId>', {
     *   publishers: ['Orchestrator', 'Actions'],
     * });
     * ```
     * @internal
     */
    getAll(tenantId: string, options?: SubscriptionGetAllOptions): Promise<SubscriptionGetResponse>;
    /**
     * Lists available publishers and their topics, regardless of the user's current subscription.
     *
     * Used for discovery — pair with {@link getAll} to inspect what's subscribable.
     *
     * Note: the response from this endpoint carries only identity/discovery fields on
     * publishers and topics (no subscription state). Use {@link getAll} to inspect state.
     *
     * @param tenantId - Tenant GUID
     * @param options - Optional publisher-name filter
     * @returns Publishers and their full topic catalogue (discovery fields only)
     * {@link SubscriptionGetPublishersResponse}
     *
     * @example Basic usage
     * ```typescript
     * const { publishers } = await subscriptions.getPublishers('<tenantId>');
     * ```
     *
     * @example Filter to a single publisher
     * ```typescript
     * const { publishers } = await subscriptions.getPublishers('<tenantId>', { name: 'Orchestrator' });
     * ```
     * @internal
     */
    getPublishers(tenantId: string, options?: SubscriptionGetPublishersOptions): Promise<SubscriptionGetPublishersResponse>;
    /**
     * Gets the notification channels supported in the current tenant.
     *
     * Check the `isEnabled` field on each {@link SupportedChannel} before attempting to subscribe to a
     * channel — disabled channels will be rejected by the server.
     *
     * Note: `InApp` is always available and is not included in the response.
     *
     * @param tenantId - Tenant GUID
     * @returns Supported channels with enabled status
     * {@link SubscriptionGetSupportedChannelsResponse}
     *
     * @example
     * ```typescript
     * import { NotificationMode } from '@uipath/uipath-typescript/notifications';
     *
     * const { channels } = await subscriptions.getSupportedChannels('<tenantId>');
     * const slack = channels.find(c => c.name === NotificationMode.Slack);
     * if (slack?.isEnabled) {
     *   // safe to subscribe to Slack
     * }
     * ```
     * @internal
     */
    getSupportedChannels(tenantId: string): Promise<SubscriptionGetSupportedChannelsResponse>;
}

/**
 * SubscriptionService — manages the current user's notification preferences.
 */

/**
 * Service for managing the current user's notification subscription preferences.
 *
 * Subscriptions are scoped to publishers (e.g. `Orchestrator`, `Actions`) and topics
 * within them. Each topic can be activated per notification channel (InApp, Email,
 * Slack, Teams) — see {@link NotificationMode}.
 *
 * Every public method takes the acting tenant GUID as the first argument, which the
 * SDK forwards to the subscription API on each call.
 */
declare class SubscriptionService extends BaseService implements SubscriptionServiceModel {
    getAll(tenantId: string, options?: SubscriptionGetAllOptions): Promise<SubscriptionGetResponse>;
    getPublishers(tenantId: string, options?: SubscriptionGetPublishersOptions): Promise<SubscriptionGetPublishersResponse>;
    getSupportedChannels(tenantId: string): Promise<SubscriptionGetSupportedChannelsResponse>;
}

export { EntitySyncOperation, NotificationCategory, NotificationMode, NotificationPriority, NotificationService as Notifications, SubscriptionService as Subscriptions };
export type { AllowedMode, EntitySyncEvent, NotificationDeleteAllResponse, NotificationDeleteResponse, NotificationGetAllOptions, NotificationGetResponse, NotificationMarkAllReadResponse, NotificationServiceModel, NotificationUpdateReadResponse, SubscriptionEntity, SubscriptionEntityType, SubscriptionGetAllOptions, SubscriptionGetPublishersOptions, SubscriptionGetPublishersResponse, SubscriptionGetResponse, SubscriptionGetSupportedChannelsResponse, SubscriptionMode, SubscriptionPublisher, SubscriptionPublisherBase, SubscriptionServiceModel, SubscriptionTopic, SubscriptionTopicBase, SupportedChannel, TopicGroupEntity, TopicGroupEntityType };