iya-sts
    Preparing search index...

    Variable export=

    "export=": {
        addAccountObserver: (fn: any) => void;
        addGroupMember: (group: any, member: any, options: any) => any;
        addGroupOwner: (group: any, owner: any, options: any) => any;
        adoptEntry: (dn: any, attributes: any, origin: any) => any;
        allGroupEntries: () => {
            attributes: {};
            createdAt: any;
            dn: any;
            modifiedAt: any;
            operational: any[];
            origin: any;
        }[];
        allPersons: () => any[];
        applicationsDn: () => string;
        applyOperationResult: (
            operation: any,
            req: any,
            res: any,
            next: any,
            result: any,
        ) => any;
        autoCreateUser: (detail: any) => any;
        autocreateUsers: () => any;
        baseDn: () => string;
        boundConnections: () => any;
        CANDIDATE_COUNT_CAP: number;
        candidateByNameAsync: (
            name: any,
        ) => Promise<{ inDirectory: boolean; seen: boolean; username: string }>;
        candidatePageAsync: (
            offset: any,
            limit: any,
            needle: any,
            options: any,
        ) => Promise<
            {
                complete: boolean;
                countCapped: boolean;
                incomplete: { cap: number; capped: boolean; short: any; unusable: any };
                matched: any;
                rows: any[];
                total: any;
            },
        >;
        certificateHolders: (sha256: any) => any[];
        certificateIndexState: () => {
            builds: any;
            certificatesVersion: number;
            version: any;
        };
        changeStoredCertificate: (
            kind: any,
            id: any,
            change: any,
        ) =>
            | { changed?: undefined; dn?: undefined; ok: boolean }
            | { changed: boolean; dn: string; ok: boolean };
        claimCreate: (
            what: any,
        ) => Promise<HeldClaim> | Promise<{ ok: boolean; settle: () => void }>;
        close: () => void;
        clusterConnectionsReport: () => object;
        connectionSnapshot: () => any;
        createGroup: (displayName: any, options: any) => any;
        createUser: (name: any, options: any) => any;
        credentialCensus: (names: any) => any;
        credentialCensusAsync: (names: any, counter: any) => Promise<any>;
        DELEGATE_CANDIDATE_CAP: number;
        DELEGATE_CANDIDATE_MIN: number;
        DELEGATE_CANDIDATE_OVERFETCH: number;
        delegateCandidates: (
            needle: any,
            options: any,
        ) => Promise<{ more: boolean; people: any[] }>;
        delegateCandidatesOfPage: (
            rows: any,
            answered: any,
            asked: any,
            cap: any,
            selfKey: any,
        ) => { more: boolean; people: any[] };
        deleteGroupEntry: (dn: any) => any;
        deletePerson: (dn: any, options: any) => any;
        directoryHooks: {
            applyEntry: (realmId: any, key: any, row: any) => void;
            entryAt: (realmId: any, key: any) => any;
            forgetEntry: (realmId: any, key: any, row: any, keep: any) => void;
            realmEntries: (realmId: any) => any[];
            removeEntry: (realmId: any, key: any) => void;
            replaceRealm: (realmId: any, list: any) => void;
            window: export=;
            windowedContainers: (realmId: any) => string[];
        };
        directoryIsWindowed: () => boolean;
        directoryWindow: export=;
        dispatchableOperations: () => string[];
        dnForResourceId: (id: any) => any;
        dropConnectionsFor: (key: any, options: any) => any;
        dropMemberships: (dn: any) => number;
        entries: any;
        entriesByTimeRangeAsync: (
            column: any,
            lo: any,
            hi: any,
            cap: any,
            partial: any,
        ) => Promise<any>;
        entriesByUuids: (uuids: any) => Map<any, any>;
        entriesByUuidsAsync: (uuids: any) => Promise<Map<any, any>>;
        entryByUuid: (uuid: any) => any;
        entryCount: () => any;
        entryUuidOf: (stored: any) => string;
        existingUserEntriesAsync: (names: any, counter: any) => Promise<any>;
        existingUserEntry: (name: any) => any;
        GROUP_POLICY_REFERENCES: string[];
        groupChoices: (
            wanted: any,
            from: any,
            limit: any,
            exclude: any,
        ) => { from: number; matched: number; rows: any[]; total: any };
        groupDnFor: (displayName: any) => string;
        groupIndexState: (
            compare: any,
        ) => { builds: any; current: boolean; groupsVersion: number; version: any };
        groupMembersAfterAsync: (
            selectors: any,
            after: any,
            limit: any,
        ) => Promise<
            {
                dn: any;
                done: boolean;
                found: boolean;
                groups: any[];
                next: any;
                rows: any[];
            },
        >;
        groupOwnership: (
            group: any,
        ) => { cn: string; dn: any; ownerProtected: boolean; owners: any };
        groupsDn: () => string;
        groupsFor: (
            dn: any,
        ) => {
            baseDn: string;
            entryCount: any;
            groupsDn: string;
            ldapsListening: boolean;
            ldapsPort: any;
            listenError: string;
            listening: boolean;
            maxEntries: any;
            port: any;
            usersDn: string;
        };
        groupsNamed: (selectors: any) => any[];
        groupsNamingPolicy: (attribute: any, name: any) => any;
        groupsOfUser: (
            key: any,
        ) => {
            baseDn: string;
            dn: string;
            entryFound: boolean;
            groups: any[];
            groupsDn: string;
            key: string;
        };
        groupsOwnedBy: (dns: any) => any[];
        holderCountAsync: (kind: any, attribute: any, upTo: any) => Promise<any>;
        holdersAsync: (
            kind: any,
            attribute: any,
            names: any,
            control: any,
        ) => Promise<any[]>;
        holdSocket: (socket: any) => void;
        indexedLookupsOf: (filter: any, depth: any) => any;
        inPersonBatch: (fn: any, options: any) => any;
        isPersonEntry: (stored: any) => boolean;
        LDAP_PORT: any;
        ldapDevicesView: (
            req: any,
        ) =>
            | Promise<
                {
                    json: {
                        baseDn: string;
                        container: string;
                        count: number;
                        entries: any;
                        filter: { q: string };
                        firstRow: number;
                        lastRow: number;
                        matched: number;
                        page: number;
                        pages: number;
                        paging: {
                            firstRow: any;
                            lastRow: any;
                            noun: any;
                            page: any;
                            pages: any;
                            param: any;
                            perPage: any;
                            total: any;
                        };
                        perPage: number;
                        schema: any;
                        shown: any;
                        sourceOfTruth: string;
                    };
                    title: string;
                },
            >
            | {
                json: {
                    baseDn: string;
                    container: string;
                    count: any;
                    entries: any;
                    filter: { q: string };
                    firstRow: number;
                    lastRow: number;
                    matched: any;
                    page: number;
                    pages: number;
                    paging: {
                        firstRow: any;
                        lastRow: any;
                        noun: any;
                        page: any;
                        pages: any;
                        param: any;
                        perPage: any;
                        total: any;
                    };
                    perPage: number;
                    schema: any;
                    shown: any;
                    sourceOfTruth: string;
                };
                title: string;
            };
        ldapDirectoryView: (
            req: any,
        ) =>
            | Promise<
                {
                    json: {
                        baseDn: string;
                        count: number;
                        entries: any[];
                        filter: { origin: string; q: string };
                        firstRow: number;
                        lastRow: number;
                        matched: number;
                        order: string;
                        originCounts: {};
                        origins: string[];
                        page: number;
                        pages: number;
                        paging: {
                            firstRow: any;
                            lastRow: any;
                            noun: any;
                            page: any;
                            pages: any;
                            param: any;
                            perPage: any;
                            total: any;
                        };
                        perPage: number;
                        search: { complete: boolean; scanLimit: number; scanned: number };
                        shown: number;
                    };
                    title: string;
                },
            >
            | {
                json: {
                    baseDn: string;
                    count: number;
                    entries: any;
                    filter: { origin: string; q: string };
                    firstRow: number;
                    lastRow: number;
                    matched: number;
                    order: string;
                    originCounts: {};
                    origins: any[];
                    page: number;
                    pages: number;
                    paging: {
                        firstRow: any;
                        lastRow: any;
                        noun: any;
                        page: any;
                        pages: any;
                        param: any;
                        perPage: any;
                        total: any;
                    };
                    perPage: number;
                    search: any;
                    shown: any;
                };
                title: string;
            };
        ldapErrorNamed: (name: any, message: any) => any;
        LDAPS_PORT: any;
        ldapServiceView: (
            req: any,
        ) => {
            json: {
                authenticationFacts: string;
                autoCreateRule: string;
                autoCreateUsers: any;
                baseDn: string;
                bindPolicy: string;
                certificateProvenance: string;
                enforcedRules: string[];
                groupsDn: string;
                implementation: string;
                ldapPort: any;
                ldapsPort: any;
                ldapVersion: number;
                limits: {
                    currentEntries: any;
                    currentEntriesEverywhere: number;
                    maxEntries: any;
                    maxSearchResults: any;
                };
                listenError: string;
                listening: boolean;
                namingContexts: string[];
                operations: string[];
                persistence: {
                    answersAfterCommit: boolean;
                    cells: {
                        cell: string;
                        globalReplication: any;
                        jurisdiction: string;
                        routing: any;
                    };
                    commitBacklog: boolean;
                    configuredMode: any;
                    coordinates: boolean;
                    database: | {
                        caFile: string;
                        database: string;
                        encrypted: boolean;
                        host: string;
                        note?: undefined;
                        passwordFrom: any;
                        passwordProvider: string;
                        passwordSecret: {
                            configured: boolean;
                            field: any;
                            known: boolean;
                            label: string;
                            provider: string;
                            providers: { id: string; label: string }[];
                            secret: any;
                            shared: boolean;
                            where: {};
                        };
                        port: string;
                        sslmode: string;
                        tls: string;
                        user: string;
                        verifyCertificate: boolean;
                    }
                    | {
                        caFile?: undefined;
                        database: any;
                        encrypted: boolean;
                        host: any;
                        note: string;
                        passwordFrom?: undefined;
                        passwordProvider?: undefined;
                        passwordSecret?: undefined;
                        port: any;
                        sslmode: string;
                        tls: string;
                        user: any;
                        verifyCertificate: boolean;
                    };
                    dataDir: any;
                    enabled: boolean;
                    engine: string;
                    entriesTracked: number;
                    eventLoop: {
                        lastReport: any;
                        sinceReport: {
                            at: string;
                            maxMs: number;
                            meanMs: number;
                            p99Ms: number;
                        };
                        warnAboveMs: number;
                    };
                    failures: number;
                    healthy: boolean;
                    lastError: string;
                    lastWriteAt: any;
                    liveness: any;
                    minted: {
                        droppedPoison: number;
                        droppedUnknown: number;
                        droppedUnreadable: number;
                        failures: number;
                        handles: { handle: any; scope: any; shape: any }[];
                        lastError: string;
                        lastWriteAt: any;
                        mode: string;
                        pending: number;
                        persisting: boolean;
                        poisonDrops: {
                            at: any;
                            code: any;
                            handles: any;
                            message: any;
                            realms: any;
                            rows: any;
                        }[];
                        restored: number;
                        restoredAt: any;
                        retentionMs: number;
                        rowsDeleted: number;
                        rowsWritten: number;
                        sealed: boolean;
                        setting: boolean;
                        shared: number;
                        stores: number;
                        supported: boolean;
                        unsupportedReason: string;
                        writes: number;
                    };
                    mode: string;
                    note: string;
                    origin: { adopted: boolean; origin: any; why: any };
                    pending: boolean;
                    persistsAppconfig: any;
                    persistsDirectory: boolean;
                    persistsRealms: any;
                    realmsTracked: number;
                    replication: {
                        appliedSeq: number;
                        byKind: {};
                        coordinating: boolean;
                        failures: number;
                        highestSeq: number;
                        holeRanges: number;
                        holes: number;
                        holesAbandoned: number;
                        lastError: string;
                        lastPullAt: any;
                        note: string;
                        nudges: number;
                        originsDropped: number;
                        otherProcesses: number;
                        pollIntervalMs: number;
                        pulls: number;
                        retention: {
                            declaredGoneAt: any;
                            fanInGraceS: number;
                            lastTrim: any;
                            readerTtlS: number;
                            reportedAt: string;
                            reportError: string;
                            retentionS: number;
                            trimming: boolean;
                        };
                        rowsApplied: number;
                        startedAt: any;
                        supported: boolean;
                    };
                    restored: { entries: number; overrides: number; realms: number };
                    restoredAt: any;
                    retryArmed: boolean;
                    usedAssertions: {
                        atomicAcrossProcesses: boolean;
                        cap: number;
                        kind: string;
                        live: any;
                        liveIsCurrent: boolean;
                        persistent: boolean;
                        store: string;
                        why: string;
                    };
                    writeDelayMs: any;
                    writes: number;
                };
                port: any;
                referentialIntegrity: boolean;
                refusedPassword: string;
                schema: string;
                searchScope: string;
                specifications: string[];
                tls: {
                    certificate: {
                        fingerprint256: any;
                        names: any;
                        notAfter: any;
                        source: string;
                        subject: any;
                    };
                    clientCertificateMode: string;
                    clientCertificates: string;
                    error: string;
                    ldaps: boolean;
                    listening: boolean;
                    port: any;
                    saslExternal: {
                        available: boolean;
                        mechanisms: string[];
                        outsideCertificateAuthorities: boolean;
                        rule: string;
                    };
                    startTls: boolean;
                    url: string;
                };
                url: string;
                usersDn: string;
            };
            title: string;
        };
        listen: () => { secureServer: any; server: any; whenReady: Promise<any> };
        localBoundConnections: () => any;
        localHandler: (operation: any) => any;
        locateEntry: (key: any) => { dn: any; stored: any };
        locateStoredAsync: (key: any) => Promise<any>;
        MAX_GROUP_OWNERS: number;
        maxApplications: () => any;
        maxEntries: () => any;
        maxSearchResults: () => any;
        memberDnFor: (
            nameOrDn: any,
        ) => { dn: any; present: boolean; wasDn: boolean };
        mergeCreateRace: (
            local: any,
            incoming: any,
        ) => { aliases: string[]; uuid: string };
        nameUsableInDn: (name: any) => boolean;
        normalizeDn: (value: any) => string;
        objectFor: (
            name: any,
        ) => {
            alsoNamed: any[];
            autoCreateUsers: any;
            baseDn: string;
            dn: any;
            entry: any;
            entryCount: any;
            found: boolean;
            full: boolean;
            ldapsListening: boolean;
            ldapsPort: any;
            listenError: string;
            listening: boolean;
            maxEntries: any;
            port: any;
            usersDn: string;
        };
        openHeldNameWatches: () => number;
        operationContext: (
            operation: any,
            shape: any,
        ) => {
            connection: {
                encrypted: boolean;
                ldap: { bindDN: any };
                remoteAddress: any;
            };
            dn: any;
        };
        operationRequest: (
            operation: any,
            req: any,
        ) => { boundDn: string; channel: string; dn: any; remoteAddress: string };
        passkeyPopulationAsync: (
            selectors: any,
            limit: any,
        ) => Promise<
            { complete: boolean; groups: any[]; members: number; rows: any[] },
        >;
        passkeyScanAsync: (
            ask: any,
        ) => Promise<{ done: boolean; next: string; read: number }>;
        peopleNamingPolicyAsync: (
            attribute: any,
            name: any,
            limit: any,
        ) => Promise<{ complete: boolean; people: any[] }>;
        performOperation: (
            operation: any,
            shape: any,
            emit: any,
        ) =>
            | {
                bindDN?: undefined;
                endArg?: undefined;
                entries: any;
                error: any;
                errorName: any;
                ok: boolean;
            }
            | {
                bindDN?: undefined;
                endArg?: undefined;
                entries?: undefined;
                error: string;
                errorName: string;
                ok: boolean;
            }
            | {
                bindDN: any;
                endArg: any;
                entries: any;
                error?: undefined;
                errorName?: undefined;
                ok: boolean;
            }
            | Promise<
                | {
                    bindDN?: undefined;
                    endArg?: undefined;
                    entries: any;
                    error: any;
                    errorName: any;
                    ok: boolean;
                }
                | {
                    bindDN?: undefined;
                    endArg?: undefined;
                    entries?: undefined;
                    error: string;
                    errorName: string;
                    ok: boolean;
                }
                | {
                    bindDN: any;
                    endArg: any;
                    entries: any;
                    error?: undefined;
                    errorName?: undefined;
                    ok: boolean;
                },
            >;
        personBatchStep: () => Promise<any>;
        personCount: () => any;
        personDns: () => any;
        personGroupReferences: (
            key: any,
            attribute: any,
        ) => { cn: string; dn: string; value: string }[];
        personNameOf: (stored: any) => string;
        personNames: () => any[];
        personsHolding: (attribute: any) => any[];
        populateVcAttributes: () => | {
            attributes: string[];
            changed: number;
            examined: number;
            skipped: string;
            values: number;
        }
        | {
            attributes: string[];
            changed: number;
            examined: number;
            skipped?: undefined;
            values: number;
        };
        populateVcAttributesAt: (
            dn: any,
        ) =>
            | {
                attributes?: undefined;
                changed: number;
                examined: number;
                values: number;
            }
            | {
                attributes: string[];
                changed: number;
                examined: number;
                values: number;
            };
        prose: () => Record<string, string>;
        PROSE_ROUTES: readonly string[];
        publishConnectionsSoon: () => void;
        readGroupEntry: (
            dn: any,
        ) => {
            attributes: {};
            createdAt: any;
            dn: any;
            modifiedAt: any;
            operational: any[];
            origin: any;
        };
        readPerson: (
            dn: any,
        ) => {
            attributes: {};
            createdAt: any;
            dn: any;
            modifiedAt: any;
            operational: any[];
            origin: any;
        };
        readProfilePhoto: (key: any) => string;
        REFUSED_PASSWORD: string;
        registerWorkerOperations: () => void;
        removeGroupOwner: (group: any, owner: any, options: any) => any;
        residentsPage: (
            after: any,
            limit: any,
        ) => { more: boolean; next: any; people: any[] };
        residentsPageAsync: (
            after: any,
            limit: any,
        ) => Promise<
            {
                more: boolean;
                next: string;
                people: { displayName: string; name: string; uuid: string }[];
            },
        >;
        resolveOwner: (value: any) => { dn: any; kind: string; name: string };
        resourceIdOfDn: (dn: any) => string;
        setAccountObserver: (fn: any) => void;
        setConnectionMirror: (rows: any) => void;
        setConnectionWatcher: (fn: any) => void;
        setGroupMail: (group: any, mail: any, options: any) => any;
        setGroupOwnerProtected: (group: any, flag: any, options: any) => any;
        setGroupPolicy: (
            group: any,
            attribute: any,
            value: any,
            options: any,
        ) => any;
        setRemoteDropper: (fn: any) => void;
        signOutAcrossCluster: (
            key: any,
        ) => { at: number; instructed: boolean; node: string };
        spiffeAgentsDn: () => string;
        spiffeDn: () => string;
        spiffeEntriesDn: () => string;
        storedCertificatesOf: (
            kind: any,
            id: any,
        ) => { certificates: any[]; dn: string };
        userHandleIndexState: () => {
            builds: any;
            userHandlesVersion: number;
            version: any;
        };
        usernameOfEntry: (stored: any) => string;
        usersDn: () => string;
        writeGroupEntry: (dn: any, attributes: any, origin: any) => any;
        writePerson: (dn: any, attributes: any, options: any) => any;
        writeProfilePhoto: (key: any, record: any, pictureUrl: any) => boolean;
        writePseudonyms: (
            entryOrUsername: any,
            spec: any,
        ) => Promise<
            | { ok: boolean; pending: string; pseudonyms: any; username: string }
            | { code: any; ok: boolean; sentence: any }
            | { code: string; ok: boolean },
        >;
    }

    Type Declaration

    • addAccountObserver: (fn: any) => void
    • addGroupMember: (group: any, member: any, options: any) => any
    • addGroupOwner: (group: any, owner: any, options: any) => any
    • adoptEntry: (dn: any, attributes: any, origin: any) => any
    • allGroupEntries: () => {
          attributes: {};
          createdAt: any;
          dn: any;
          modifiedAt: any;
          operational: any[];
          origin: any;
      }[]
    • allPersons: () => any[]
    • applicationsDn: () => string
    • applyOperationResult: (operation: any, req: any, res: any, next: any, result: any) => any
    • autoCreateUser: (detail: any) => any
    • autocreateUsers: () => any
    • baseDn: () => string
    • boundConnections: () => any
    • CANDIDATE_COUNT_CAP: number
    • candidateByNameAsync: (
          name: any,
      ) => Promise<{ inDirectory: boolean; seen: boolean; username: string }>
    • candidatePageAsync: (
          offset: any,
          limit: any,
          needle: any,
          options: any,
      ) => Promise<
          {
              complete: boolean;
              countCapped: boolean;
              incomplete: { cap: number; capped: boolean; short: any; unusable: any };
              matched: any;
              rows: any[];
              total: any;
          },
      >
    • certificateHolders: (sha256: any) => any[]
    • certificateIndexState: () => { builds: any; certificatesVersion: number; version: any }
    • changeStoredCertificate: (
          kind: any,
          id: any,
          change: any,
      ) =>
          | { changed?: undefined; dn?: undefined; ok: boolean }
          | { changed: boolean; dn: string; ok: boolean }
    • claimCreate: (what: any) => Promise<HeldClaim> | Promise<{ ok: boolean; settle: () => void }>
    • close: () => void
    • clusterConnectionsReport: () => object

      Reports the cluster connection mirror's state.

    • connectionSnapshot: () => any
    • createGroup: (displayName: any, options: any) => any
    • createUser: (name: any, options: any) => any
    • credentialCensus: (names: any) => any
    • credentialCensusAsync: (names: any, counter: any) => Promise<any>
    • DELEGATE_CANDIDATE_CAP: number
    • DELEGATE_CANDIDATE_MIN: number
    • DELEGATE_CANDIDATE_OVERFETCH: number
    • delegateCandidates: (needle: any, options: any) => Promise<{ more: boolean; people: any[] }>
    • delegateCandidatesOfPage: (
          rows: any,
          answered: any,
          asked: any,
          cap: any,
          selfKey: any,
      ) => { more: boolean; people: any[] }
    • deleteGroupEntry: (dn: any) => any
    • deletePerson: (dn: any, options: any) => any
    • directoryHooks: {
          applyEntry: (realmId: any, key: any, row: any) => void;
          entryAt: (realmId: any, key: any) => any;
          forgetEntry: (realmId: any, key: any, row: any, keep: any) => void;
          realmEntries: (realmId: any) => any[];
          removeEntry: (realmId: any, key: any) => void;
          replaceRealm: (realmId: any, list: any) => void;
          window: export=;
          windowedContainers: (realmId: any) => string[];
      }
    • directoryIsWindowed: () => boolean
    • directoryWindow: export=
    • dispatchableOperations: () => string[]

      Lists the LDAP operations that can be dispatched to a request worker.

    • dnForResourceId: (id: any) => any
    • dropConnectionsFor: (key: any, options: any) => any
    • dropMemberships: (dn: any) => number
    • entries: any
    • entriesByTimeRangeAsync: (column: any, lo: any, hi: any, cap: any, partial: any) => Promise<any>
    • entriesByUuids: (uuids: any) => Map<any, any>
    • entriesByUuidsAsync: (uuids: any) => Promise<Map<any, any>>
    • entryByUuid: (uuid: any) => any
    • entryCount: () => any
    • entryUuidOf: (stored: any) => string
    • existingUserEntriesAsync: (names: any, counter: any) => Promise<any>
    • existingUserEntry: (name: any) => any
    • GROUP_POLICY_REFERENCES: string[]
    • groupChoices: (
          wanted: any,
          from: any,
          limit: any,
          exclude: any,
      ) => { from: number; matched: number; rows: any[]; total: any }
    • groupDnFor: (displayName: any) => string
    • groupIndexState: (
          compare: any,
      ) => { builds: any; current: boolean; groupsVersion: number; version: any }
    • groupMembersAfterAsync: (
          selectors: any,
          after: any,
          limit: any,
      ) => Promise<
          {
              dn: any;
              done: boolean;
              found: boolean;
              groups: any[];
              next: any;
              rows: any[];
          },
      >
    • groupOwnership: (group: any) => { cn: string; dn: any; ownerProtected: boolean; owners: any }
    • groupsDn: () => string
    • groupsFor: (
          dn: any,
      ) => {
          baseDn: string;
          entryCount: any;
          groupsDn: string;
          ldapsListening: boolean;
          ldapsPort: any;
          listenError: string;
          listening: boolean;
          maxEntries: any;
          port: any;
          usersDn: string;
      }
    • groupsNamed: (selectors: any) => any[]
    • groupsNamingPolicy: (attribute: any, name: any) => any
    • groupsOfUser: (
          key: any,
      ) => {
          baseDn: string;
          dn: string;
          entryFound: boolean;
          groups: any[];
          groupsDn: string;
          key: string;
      }
    • groupsOwnedBy: (dns: any) => any[]
    • holderCountAsync: (kind: any, attribute: any, upTo: any) => Promise<any>
    • holdersAsync: (kind: any, attribute: any, names: any, control: any) => Promise<any[]>
    • holdSocket: (socket: any) => void
    • indexedLookupsOf: (filter: any, depth: any) => any
    • inPersonBatch: (fn: any, options: any) => any
    • isPersonEntry: (stored: any) => boolean
    • LDAP_PORT: any
    • ldapDevicesView: (
          req: any,
      ) =>
          | Promise<
              {
                  json: {
                      baseDn: string;
                      container: string;
                      count: number;
                      entries: any;
                      filter: { q: string };
                      firstRow: number;
                      lastRow: number;
                      matched: number;
                      page: number;
                      pages: number;
                      paging: {
                          firstRow: any;
                          lastRow: any;
                          noun: any;
                          page: any;
                          pages: any;
                          param: any;
                          perPage: any;
                          total: any;
                      };
                      perPage: number;
                      schema: any;
                      shown: any;
                      sourceOfTruth: string;
                  };
                  title: string;
              },
          >
          | {
              json: {
                  baseDn: string;
                  container: string;
                  count: any;
                  entries: any;
                  filter: { q: string };
                  firstRow: number;
                  lastRow: number;
                  matched: any;
                  page: number;
                  pages: number;
                  paging: {
                      firstRow: any;
                      lastRow: any;
                      noun: any;
                      page: any;
                      pages: any;
                      param: any;
                      perPage: any;
                      total: any;
                  };
                  perPage: number;
                  schema: any;
                  shown: any;
                  sourceOfTruth: string;
              };
              title: string;
          }
    • ldapDirectoryView: (
          req: any,
      ) =>
          | Promise<
              {
                  json: {
                      baseDn: string;
                      count: number;
                      entries: any[];
                      filter: { origin: string; q: string };
                      firstRow: number;
                      lastRow: number;
                      matched: number;
                      order: string;
                      originCounts: {};
                      origins: string[];
                      page: number;
                      pages: number;
                      paging: {
                          firstRow: any;
                          lastRow: any;
                          noun: any;
                          page: any;
                          pages: any;
                          param: any;
                          perPage: any;
                          total: any;
                      };
                      perPage: number;
                      search: { complete: boolean; scanLimit: number; scanned: number };
                      shown: number;
                  };
                  title: string;
              },
          >
          | {
              json: {
                  baseDn: string;
                  count: number;
                  entries: any;
                  filter: { origin: string; q: string };
                  firstRow: number;
                  lastRow: number;
                  matched: number;
                  order: string;
                  originCounts: {};
                  origins: any[];
                  page: number;
                  pages: number;
                  paging: {
                      firstRow: any;
                      lastRow: any;
                      noun: any;
                      page: any;
                      pages: any;
                      param: any;
                      perPage: any;
                      total: any;
                  };
                  perPage: number;
                  search: any;
                  shown: any;
              };
              title: string;
          }
    • ldapErrorNamed: (name: any, message: any) => any
    • LDAPS_PORT: any
    • ldapServiceView: (
          req: any,
      ) => {
          json: {
              authenticationFacts: string;
              autoCreateRule: string;
              autoCreateUsers: any;
              baseDn: string;
              bindPolicy: string;
              certificateProvenance: string;
              enforcedRules: string[];
              groupsDn: string;
              implementation: string;
              ldapPort: any;
              ldapsPort: any;
              ldapVersion: number;
              limits: {
                  currentEntries: any;
                  currentEntriesEverywhere: number;
                  maxEntries: any;
                  maxSearchResults: any;
              };
              listenError: string;
              listening: boolean;
              namingContexts: string[];
              operations: string[];
              persistence: {
                  answersAfterCommit: boolean;
                  cells: {
                      cell: string;
                      globalReplication: any;
                      jurisdiction: string;
                      routing: any;
                  };
                  commitBacklog: boolean;
                  configuredMode: any;
                  coordinates: boolean;
                  database: | {
                      caFile: string;
                      database: string;
                      encrypted: boolean;
                      host: string;
                      note?: undefined;
                      passwordFrom: any;
                      passwordProvider: string;
                      passwordSecret: {
                          configured: boolean;
                          field: any;
                          known: boolean;
                          label: string;
                          provider: string;
                          providers: { id: string; label: string }[];
                          secret: any;
                          shared: boolean;
                          where: {};
                      };
                      port: string;
                      sslmode: string;
                      tls: string;
                      user: string;
                      verifyCertificate: boolean;
                  }
                  | {
                      caFile?: undefined;
                      database: any;
                      encrypted: boolean;
                      host: any;
                      note: string;
                      passwordFrom?: undefined;
                      passwordProvider?: undefined;
                      passwordSecret?: undefined;
                      port: any;
                      sslmode: string;
                      tls: string;
                      user: any;
                      verifyCertificate: boolean;
                  };
                  dataDir: any;
                  enabled: boolean;
                  engine: string;
                  entriesTracked: number;
                  eventLoop: {
                      lastReport: any;
                      sinceReport: {
                          at: string;
                          maxMs: number;
                          meanMs: number;
                          p99Ms: number;
                      };
                      warnAboveMs: number;
                  };
                  failures: number;
                  healthy: boolean;
                  lastError: string;
                  lastWriteAt: any;
                  liveness: any;
                  minted: {
                      droppedPoison: number;
                      droppedUnknown: number;
                      droppedUnreadable: number;
                      failures: number;
                      handles: { handle: any; scope: any; shape: any }[];
                      lastError: string;
                      lastWriteAt: any;
                      mode: string;
                      pending: number;
                      persisting: boolean;
                      poisonDrops: {
                          at: any;
                          code: any;
                          handles: any;
                          message: any;
                          realms: any;
                          rows: any;
                      }[];
                      restored: number;
                      restoredAt: any;
                      retentionMs: number;
                      rowsDeleted: number;
                      rowsWritten: number;
                      sealed: boolean;
                      setting: boolean;
                      shared: number;
                      stores: number;
                      supported: boolean;
                      unsupportedReason: string;
                      writes: number;
                  };
                  mode: string;
                  note: string;
                  origin: { adopted: boolean; origin: any; why: any };
                  pending: boolean;
                  persistsAppconfig: any;
                  persistsDirectory: boolean;
                  persistsRealms: any;
                  realmsTracked: number;
                  replication: {
                      appliedSeq: number;
                      byKind: {};
                      coordinating: boolean;
                      failures: number;
                      highestSeq: number;
                      holeRanges: number;
                      holes: number;
                      holesAbandoned: number;
                      lastError: string;
                      lastPullAt: any;
                      note: string;
                      nudges: number;
                      originsDropped: number;
                      otherProcesses: number;
                      pollIntervalMs: number;
                      pulls: number;
                      retention: {
                          declaredGoneAt: any;
                          fanInGraceS: number;
                          lastTrim: any;
                          readerTtlS: number;
                          reportedAt: string;
                          reportError: string;
                          retentionS: number;
                          trimming: boolean;
                      };
                      rowsApplied: number;
                      startedAt: any;
                      supported: boolean;
                  };
                  restored: { entries: number; overrides: number; realms: number };
                  restoredAt: any;
                  retryArmed: boolean;
                  usedAssertions: {
                      atomicAcrossProcesses: boolean;
                      cap: number;
                      kind: string;
                      live: any;
                      liveIsCurrent: boolean;
                      persistent: boolean;
                      store: string;
                      why: string;
                  };
                  writeDelayMs: any;
                  writes: number;
              };
              port: any;
              referentialIntegrity: boolean;
              refusedPassword: string;
              schema: string;
              searchScope: string;
              specifications: string[];
              tls: {
                  certificate: {
                      fingerprint256: any;
                      names: any;
                      notAfter: any;
                      source: string;
                      subject: any;
                  };
                  clientCertificateMode: string;
                  clientCertificates: string;
                  error: string;
                  ldaps: boolean;
                  listening: boolean;
                  port: any;
                  saslExternal: {
                      available: boolean;
                      mechanisms: string[];
                      outsideCertificateAuthorities: boolean;
                      rule: string;
                  };
                  startTls: boolean;
                  url: string;
              };
              url: string;
              usersDn: string;
          };
          title: string;
      }
    • listen: () => { secureServer: any; server: any; whenReady: Promise<any> }
    • localBoundConnections: () => any
    • localHandler: (operation: any) => any

      Returns the handler a request worker runs for an operation.

    • locateEntry: (key: any) => { dn: any; stored: any }
    • locateStoredAsync: (key: any) => Promise<any>
    • MAX_GROUP_OWNERS: number
    • maxApplications: () => any
    • maxEntries: () => any
    • maxSearchResults: () => any
    • memberDnFor: (nameOrDn: any) => { dn: any; present: boolean; wasDn: boolean }
    • mergeCreateRace: (local: any, incoming: any) => { aliases: string[]; uuid: string }
    • nameUsableInDn: (name: any) => boolean
    • normalizeDn: (value: any) => string
    • objectFor: (
          name: any,
      ) => {
          alsoNamed: any[];
          autoCreateUsers: any;
          baseDn: string;
          dn: any;
          entry: any;
          entryCount: any;
          found: boolean;
          full: boolean;
          ldapsListening: boolean;
          ldapsPort: any;
          listenError: string;
          listening: boolean;
          maxEntries: any;
          port: any;
          usersDn: string;
      }
    • openHeldNameWatches: () => number
    • operationContext: (
          operation: any,
          shape: any,
      ) => {
          connection: {
              encrypted: boolean;
              ldap: { bindDN: any };
              remoteAddress: any;
          };
          dn: any;
      }
    • operationRequest: (
          operation: any,
          req: any,
      ) => { boundDn: string; channel: string; dn: any; remoteAddress: string }
    • passkeyPopulationAsync: (
          selectors: any,
          limit: any,
      ) => Promise<
          { complete: boolean; groups: any[]; members: number; rows: any[] },
      >
    • passkeyScanAsync: (ask: any) => Promise<{ done: boolean; next: string; read: number }>
    • peopleNamingPolicyAsync: (
          attribute: any,
          name: any,
          limit: any,
      ) => Promise<{ complete: boolean; people: any[] }>
    • performOperation: (
          operation: any,
          shape: any,
          emit: any,
      ) =>
          | {
              bindDN?: undefined;
              endArg?: undefined;
              entries: any;
              error: any;
              errorName: any;
              ok: boolean;
          }
          | {
              bindDN?: undefined;
              endArg?: undefined;
              entries?: undefined;
              error: string;
              errorName: string;
              ok: boolean;
          }
          | {
              bindDN: any;
              endArg: any;
              entries: any;
              error?: undefined;
              errorName?: undefined;
              ok: boolean;
          }
          | Promise<
              | {
                  bindDN?: undefined;
                  endArg?: undefined;
                  entries: any;
                  error: any;
                  errorName: any;
                  ok: boolean;
              }
              | {
                  bindDN?: undefined;
                  endArg?: undefined;
                  entries?: undefined;
                  error: string;
                  errorName: string;
                  ok: boolean;
              }
              | {
                  bindDN: any;
                  endArg: any;
                  entries: any;
                  error?: undefined;
                  errorName?: undefined;
                  ok: boolean;
              },
          >
    • personBatchStep: () => Promise<any>
    • personCount: () => any
    • personDns: () => any
    • personGroupReferences: (key: any, attribute: any) => { cn: string; dn: string; value: string }[]
    • personNameOf: (stored: any) => string
    • personNames: () => any[]
    • personsHolding: (attribute: any) => any[]
    • populateVcAttributes: () => | {
          attributes: string[];
          changed: number;
          examined: number;
          skipped: string;
          values: number;
      }
      | {
          attributes: string[];
          changed: number;
          examined: number;
          skipped?: undefined;
          values: number;
      }
    • populateVcAttributesAt: (
          dn: any,
      ) =>
          | {
              attributes?: undefined;
              changed: number;
              examined: number;
              values: number;
          }
          | {
              attributes: string[];
              changed: number;
              examined: number;
              values: number;
          }
    • prose: () => Record<string, string>
    • PROSE_ROUTES: readonly string[]
    • publishConnectionsSoon: () => void
    • readGroupEntry: (
          dn: any,
      ) => {
          attributes: {};
          createdAt: any;
          dn: any;
          modifiedAt: any;
          operational: any[];
          origin: any;
      }
    • readPerson: (
          dn: any,
      ) => {
          attributes: {};
          createdAt: any;
          dn: any;
          modifiedAt: any;
          operational: any[];
          origin: any;
      }
    • readProfilePhoto: (key: any) => string
    • REFUSED_PASSWORD: string
    • registerWorkerOperations: () => void
    • removeGroupOwner: (group: any, owner: any, options: any) => any
    • residentsPage: (after: any, limit: any) => { more: boolean; next: any; people: any[] }
    • residentsPageAsync: (
          after: any,
          limit: any,
      ) => Promise<
          {
              more: boolean;
              next: string;
              people: { displayName: string; name: string; uuid: string }[];
          },
      >
    • resolveOwner: (value: any) => { dn: any; kind: string; name: string }
    • resourceIdOfDn: (dn: any) => string
    • setAccountObserver: (fn: any) => void
    • setConnectionMirror: (rows: any) => void
    • setConnectionWatcher: (fn: any) => void
    • setGroupMail: (group: any, mail: any, options: any) => any
    • setGroupOwnerProtected: (group: any, flag: any, options: any) => any
    • setGroupPolicy: (group: any, attribute: any, value: any, options: any) => any
    • setRemoteDropper: (fn: any) => void
    • signOutAcrossCluster: (key: any) => { at: number; instructed: boolean; node: string }

      Writes a sign-out instruction for an identity to every other node.

    • spiffeAgentsDn: () => string
    • spiffeDn: () => string
    • spiffeEntriesDn: () => string
    • storedCertificatesOf: (kind: any, id: any) => { certificates: any[]; dn: string }
    • userHandleIndexState: () => { builds: any; userHandlesVersion: number; version: any }
    • usernameOfEntry: (stored: any) => string
    • usersDn: () => string
    • writeGroupEntry: (dn: any, attributes: any, origin: any) => any
    • writePerson: (dn: any, attributes: any, options: any) => any
    • writeProfilePhoto: (key: any, record: any, pictureUrl: any) => boolean
    • writePseudonyms: (
          entryOrUsername: any,
          spec: any,
      ) => Promise<
          | { ok: boolean; pending: string; pseudonyms: any; username: string }
          | { code: any; ok: boolean; sentence: any }
          | { code: string; ok: boolean },
      >