@roadiehq/catalog-backend-module-okta/dist/types/index.d-CKpeNqQk.d.ts

A set of Backstage catalog providers for Okta

import { Config } from '@backstage/config';
import { EntityProvider, EntityProviderConnection } from '@backstage/plugin-catalog-node';
import { Client, User, Group } from '@okta/okta-sdk-nodejs';
import { LoggerService } from '@backstage/backend-plugin-api';
import { GroupEntity, UserEntity } from '@backstage/catalog-model';

type AccountConfig = {
    orgUrl: string;
    token?: string;
    oauth?: {
        clientId: string;
        keyId?: string;
        privateKey: string;
    };
    userFilter?: string;
    groupFilter?: string;
};

type OktaScope = 'okta.groups.read' | 'okta.users.read';
declare abstract class OktaEntityProvider implements EntityProvider {
    protected readonly account: AccountConfig;
    protected readonly logger: LoggerService;
    protected connection?: EntityProviderConnection;
    abstract getProviderName(): string;
    protected constructor(account: AccountConfig, options: {
        logger: LoggerService;
    });
    protected getClient(orgUrl: string, oauthScopes?: OktaScope[] | undefined): Client;
    connect(connection: EntityProviderConnection): Promise<void>;
    protected buildDefaultAnnotations(): Promise<{
        "backstage.io/managed-by-location": string;
        "backstage.io/managed-by-origin-location": string;
    }>;
    protected getCustomAnnotations(member: User | Group, allowList: string[]): Record<string, string>;
    abstract run(): Promise<void>;
}

type GroupNamingStrategy = (group: Group) => string;
type GroupNamingStrategies = 'id' | 'kebab-case-name' | 'profile-name' | undefined;

declare const kebabCaseGroupNamingStrategy: GroupNamingStrategy;

declare const idGroupNamingStrategy: GroupNamingStrategy;

declare const profileNameGroupNamingStrategy: GroupNamingStrategy;

declare class ProfileFieldGroupNamingStrategy {
    private fieldName;
    constructor(fieldName: string);
    nameForGroup: GroupNamingStrategy;
}

declare const groupNamingStrategyFactory: (strategy?: GroupNamingStrategies | GroupNamingStrategy) => GroupNamingStrategy;

type UserNamingStrategy = (user: User) => string;
type UserNamingStrategies = 'id' | 'kebab-case-email' | 'strip-domain-email' | 'slugify-email' | undefined;

declare const idUserNamingStrategy: UserNamingStrategy;

declare const stripEmailDomainUserNamingStrategy: UserNamingStrategy;

declare const kebabCaseEmailUserNamingStrategy: UserNamingStrategy;

declare const userNamingStrategyFactory: (strategy?: UserNamingStrategies | UserNamingStrategy) => UserNamingStrategy;

declare const slugifyEmailUserNamingStrategy: UserNamingStrategy;

type OktaGroupEntityTransformer = (group: Group, namingStrategy: GroupNamingStrategy, options: {
    annotations: Record<string, string>;
    members: string[];
}, parentGroup?: Group) => GroupEntity;
type OktaUserEntityTransformer = (user: User, namingStrategy: UserNamingStrategy, options: {
    annotations: Record<string, string>;
}) => UserEntity;

/**
 * Provides entities from Okta Group service.
 */
declare class OktaGroupEntityProvider extends OktaEntityProvider {
    private readonly namingStrategy;
    private readonly userNamingStrategy;
    private readonly groupEntityFromOktaGroup;
    private readonly groupFilter;
    private readonly orgUrl;
    private readonly customAttributesToAnnotationAllowlist;
    private hierarchyConfig;
    private readonly chunkSize;
    static fromConfig(config: Config, options: {
        logger: LoggerService;
        namingStrategy?: GroupNamingStrategies | GroupNamingStrategy;
        userNamingStrategy?: UserNamingStrategies | UserNamingStrategy;
        groupTransformer?: OktaGroupEntityTransformer;
        customAttributesToAnnotationAllowlist?: string[];
        parentGroupField?: string;
        hierarchyConfig?: {
            parentKey: string;
            key?: string;
        };
        chunkSize?: number;
    }): OktaGroupEntityProvider;
    constructor(accountConfig: AccountConfig, options: {
        logger: LoggerService;
        namingStrategy?: GroupNamingStrategies | GroupNamingStrategy;
        userNamingStrategy?: UserNamingStrategies | UserNamingStrategy;
        customAttributesToAnnotationAllowlist?: string[];
        hierarchyConfig?: {
            parentKey: string;
            key?: string;
        };
        groupTransformer?: OktaGroupEntityTransformer;
        chunkSize?: number;
    });
    getProviderName(): string;
    run(): Promise<void>;
}

/**
 * Provides entities from Okta User service.
 */
declare class OktaUserEntityProvider extends OktaEntityProvider {
    private readonly namingStrategy;
    private readonly userEntityFromOktaUser;
    private readonly userFilter?;
    private readonly orgUrl;
    private readonly customAttributesToAnnotationAllowlist;
    static fromConfig(config: Config, options: {
        logger: LoggerService;
        customAttributesToAnnotationAllowlist?: string[];
        namingStrategy?: UserNamingStrategies | UserNamingStrategy;
        userTransformer?: OktaUserEntityTransformer;
    }): OktaUserEntityProvider;
    constructor(accountConfig: AccountConfig, options: {
        logger: LoggerService;
        customAttributesToAnnotationAllowlist?: string[];
        namingStrategy?: UserNamingStrategies | UserNamingStrategy;
        userTransformer?: OktaUserEntityTransformer;
    });
    getProviderName(): string;
    run(): Promise<void>;
}

/**
 * Provides entities from Okta Org service.
 */
declare class OktaOrgEntityProvider extends OktaEntityProvider {
    private readonly groupNamingStrategy;
    private readonly userNamingStrategy;
    private readonly groupEntityFromOktaGroup;
    private readonly userEntityFromOktaUser;
    private readonly includeEmptyGroups;
    private readonly hierarchyConfig;
    private readonly customAttributesToAnnotationAllowlist;
    private readonly chunkSize;
    static fromConfig(config: Config, options: {
        logger: LoggerService;
        groupNamingStrategy?: GroupNamingStrategies | GroupNamingStrategy;
        userNamingStrategy?: UserNamingStrategies | UserNamingStrategy;
        groupTransformer?: OktaGroupEntityTransformer;
        userTransformer?: OktaUserEntityTransformer;
        includeEmptyGroups?: boolean;
        parentGroupField?: string;
        hierarchyConfig?: {
            parentKey: string;
            key?: string;
        };
        customAttributesToAnnotationAllowlist?: string[];
        chunkSize?: number;
    }): OktaOrgEntityProvider;
    constructor(accountConfig: AccountConfig, options: {
        logger: LoggerService;
        groupNamingStrategy?: GroupNamingStrategies | GroupNamingStrategy;
        userNamingStrategy?: UserNamingStrategies | UserNamingStrategy;
        groupTransformer?: OktaGroupEntityTransformer;
        userTransformer?: OktaUserEntityTransformer;
        includeEmptyGroups?: boolean;
        hierarchyConfig?: {
            parentKey: string;
            key?: string;
        };
        customAttributesToAnnotationAllowlist?: string[];
        chunkSize?: number;
    });
    getProviderName(): string;
    run(): Promise<void>;
}

export { type GroupNamingStrategy as G, OktaEntityProvider as O, ProfileFieldGroupNamingStrategy as P, type UserNamingStrategy as U, type OktaUserEntityTransformer as a, OktaGroupEntityProvider as b, OktaUserEntityProvider as c, OktaOrgEntityProvider as d, type OktaGroupEntityTransformer as e, type GroupNamingStrategies as f, groupNamingStrategyFactory as g, type UserNamingStrategies as h, idGroupNamingStrategy as i, idUserNamingStrategy as j, kebabCaseGroupNamingStrategy as k, kebabCaseEmailUserNamingStrategy as l, slugifyEmailUserNamingStrategy as m, profileNameGroupNamingStrategy as p, stripEmailDomainUserNamingStrategy as s, userNamingStrategyFactory as u };