@noodleseed/one 0.162.0 → 0.163.0

package/node_modules/@noodle-borg/service/dist/routes/business-information-connections.js

@@ -0,0 +1,107 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { ApplicationConnectionCallbackRequestSchema, ApplicationConnectionCallbackResponseSchema, ApplicationConnectionConnectRequestSchema, ApplicationConnectionConnectResponseSchema, ApplicationConnectionDisconnectRequestSchema, ApplicationConnectionsResponseSchema, } from '@noodle-borg/wire-contracts';
+import { businessGrantAllows, } from '../business-information/portable.js';
+import { ConnectionError, } from '../connections/types.js';
+import { requireIdentity, requireInstallationPermission, } from './business-information.js';
+export async function handleApplicationConnections(req, res, ref, deps) {
+    const mutation = ref.connectionAction !== undefined;
+    if (req.method !== (mutation ? 'POST' : 'GET')) {
+        res.setHeader('allow', mutation ? 'POST' : 'GET');
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const authorized = await requireInstallationPermission(res, ref, identity, mutation ? 'installation:administer' : 'records:read', deps);
+    if (authorized === undefined)
+        return;
+    if (authorized.grant.role === 'viewer')
+        return sendJson(res, 403, {
+            code: 'connection_denied',
+            error: 'Integration access requires an operator grant.',
+        });
+    res.setHeader('cache-control', 'private, no-store');
+    if (!deps.connections || !deps.resolveConnectionTargets)
+        return failure(res, new ConnectionError('connection_unavailable'));
+    try {
+        const targets = await deps.resolveConnectionTargets(authorized.installation);
+        const connections = deps.connections;
+        const projection = async () => ({
+            connections: await Promise.all(targets.map((target) => connections.inspect(target))),
+            canEdit: businessGrantAllows(authorized.grant, 'installation:administer'),
+        });
+        if (!mutation)
+            return sendJson(res, 200, ApplicationConnectionsResponseSchema.parse({ ok: true, data: await projection() }));
+        const target = targets.find((item) => item.key.connectionId === ref.connectionId);
+        if (!target)
+            return sendJson(res, 404, {
+                code: 'connection_unavailable',
+                error: 'Connection is unavailable.',
+            });
+        const body = await readJsonBody(req, Math.min(deps.maxBody, 16_384));
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        if (ref.connectionAction === 'connect') {
+            const input = ApplicationConnectionConnectRequestSchema.safeParse(body.value);
+            if (!input.success)
+                return failure(res, new ConnectionError('connection_invalid'));
+            const data = await connections.connect(target, input.data, identity.subject);
+            return sendJson(res, 200, ApplicationConnectionConnectResponseSchema.parse({ ok: true, data }));
+        }
+        const input = ApplicationConnectionDisconnectRequestSchema.safeParse(body.value);
+        if (!input.success)
+            return failure(res, new ConnectionError('connection_invalid'));
+        await connections.disconnect(target, input.data.expectedRevision, identity.subject);
+        await deps.audit?.emit({
+            eventType: 'config.connection.disconnected',
+            org: authorized.scope.org,
+            app: authorized.scope.app,
+            env: authorized.scope.env,
+            actorSubject: identity.subject,
+            details: { connectionId: target.key.connectionId },
+        });
+        sendJson(res, 200, ApplicationConnectionsResponseSchema.parse({ ok: true, data: await projection() }));
+    }
+    catch (error) {
+        if (!(error instanceof ConnectionError))
+            throw error;
+        failure(res, error);
+    }
+}
+export async function handleApplicationConnectionCallback(req, res, deps) {
+    if (req.method !== 'POST') {
+        res.setHeader('allow', 'POST');
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    res.setHeader('cache-control', 'private, no-store');
+    if (!deps.connections)
+        return failure(res, new ConnectionError('connection_unavailable'));
+    const body = await readJsonBody(req, Math.min(deps.maxBody, 16_384));
+    if (!body.ok)
+        return sendJson(res, body.status, { error: body.error });
+    const input = ApplicationConnectionCallbackRequestSchema.safeParse(body.value);
+    if (!input.success)
+        return failure(res, new ConnectionError('connection_invalid'));
+    try {
+        const data = await deps.connections.callback(input.data, identity.subject);
+        sendJson(res, 200, ApplicationConnectionCallbackResponseSchema.parse({ ok: true, data }));
+    }
+    catch (error) {
+        if (!(error instanceof ConnectionError))
+            throw error;
+        failure(res, error);
+    }
+}
+function failure(res, error) {
+    sendJson(res, error.code === 'connection_denied'
+        ? 403
+        : error.code === 'connection_conflict'
+            ? 409
+            : error.code === 'connection_unavailable'
+                ? 503
+                : 400, { code: error.code, error: 'Connection request could not be completed.' });
+}
+//# sourceMappingURL=business-information-connections.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-dispatch.js

@@ -1,10 +1,44 @@
+import { OrganizationAgreementError } from '@noodle-borg/control-plane/portable';
+import { sendJson } from '@noodle-borg/transport-http';
+import { BusinessNoticeError } from '../business-information/business-notice.js';
+import { InstallationCapacityError } from '../business-information/installation-capacity.js';
+import { NativeStorageLimitError } from '../business-information/native-storage-budget.js';
+import { SourceCredentialError } from '../business-information/source-credential-fence.js';
+import { SourceCapacityError } from '../business-information/source-custody-budget.js';
 import { respondRouteError } from '../http-util.js';
-import { handleBusinessGrants, handleManagedRecords, handlePublicSolutionIntake, handleSolutionCatalog, handleSolutionInstallations, } from './business-information.js';
-import { parsePublicSolutionIntakePath, parseSolutionInstallationPath, } from './business-information-paths.js';
+import { handleBusinessGrants, handleManagedRecords, handleSolutionCatalog, handleSolutionInstallations, } from './business-information.js';
+import { handleApplicationActivity, } from './business-information-activity.js';
+import { handleBusinessChannels, } from './business-information-channels.js';
+import { handleApplicationConnectionCallback, handleApplicationConnections, } from './business-information-connections.js';
+import { handleBusinessNotice, handleOrganizationAgreement, } from './business-information-notice.js';
+import { handleSolutionInstallationOptions } from './business-information-onboarding.js';
+import { parsePublicSolutionIntakePath, parseSolutionInstallationPath, parseSolutionInvitationAcceptPath, } from './business-information-paths.js';
+import { handlePublicSolutionIntake } from './business-information-public.js';
+import { handleBusinessInformationReaderFloor } from './business-information-reader-floor.js';
+import { handleBusinessSettings } from './business-information-settings.js';
+import { handleCollectionSource } from './business-information-source.js';
+import { handleBusinessInvitationAccept, handleBusinessInvitations, handleEligibleBusinessAssignees, handleMySolutionInstallations, } from './business-information-staff.js';
 export function dispatchBusinessInformationRoutes(req, res, url, deps) {
+    const agreement = /^\/v1\/orgs\/([a-z0-9][a-z0-9-]{0,62})\/agreement$/.exec(url.pathname);
+    if (agreement?.[1])
+        return run(req, res, deps, () => handleOrganizationAgreement(req, res, agreement[1], deps));
+    if (url.pathname === '/v1/solution-connections/callback')
+        return run(req, res, deps, () => handleApplicationConnectionCallback(req, res, deps));
+    if (url.pathname === '/v1/service/business-information-reader-floor') {
+        return run(req, res, deps, () => handleBusinessInformationReaderFloor(req, res, deps));
+    }
     if (url.pathname === '/v1/solutions/catalog') {
         return run(req, res, deps, () => Promise.resolve(handleSolutionCatalog(req, res)));
     }
+    if (url.pathname === '/v1/me/solution-installations') {
+        return run(req, res, deps, () => handleMySolutionInstallations(req, res, deps));
+    }
+    if (url.pathname === '/v1/me/solution-installation-options')
+        return run(req, res, deps, () => handleSolutionInstallationOptions(req, res, deps));
+    const invitationToken = parseSolutionInvitationAcceptPath(url.pathname);
+    if (invitationToken !== undefined) {
+        return run(req, res, deps, () => handleBusinessInvitationAccept(req, res, invitationToken, deps));
+    }
     const publicRef = parsePublicSolutionIntakePath(url.pathname);
     if (publicRef !== undefined) {
         deps.applySecurityHeaders(res, deps.tls);
@@ -16,15 +50,43 @@ export function dispatchBusinessInformationRoutes(req, res, url, deps) {
             res.end();
             return true;
         }
-        void handlePublicSolutionIntake(req, res, publicRef, deps).catch((error) => respondRouteError(deps.logger, res, 'business_information.public_route.failed', error));
+        void handlePublicSolutionIntake(req, res, publicRef, deps).catch((error) => respondBusinessError(deps, res, 'business_information.public_route.failed', error));
         return true;
     }
     const installationRef = parseSolutionInstallationPath(url.pathname);
     if (installationRef === undefined)
         return false;
+    if (installationRef.action === 'notice')
+        return run(req, res, deps, () => handleBusinessNotice(req, res, installationRef, deps));
+    if (installationRef.action === 'activity' && installationRef.collection === undefined)
+        return run(req, res, deps, () => handleApplicationActivity(req, res, url, installationRef, deps));
+    if (installationRef.action === 'connections')
+        return run(req, res, deps, () => handleApplicationConnections(req, res, installationRef, deps));
+    if (installationRef.action === 'settings') {
+        return run(req, res, deps, () => handleBusinessSettings(req, res, installationRef, deps));
+    }
+    if (installationRef.action === 'channels' &&
+        deps.registry !== undefined &&
+        deps.resolveEndpointBase !== undefined) {
+        const channelDeps = {
+            ...deps,
+            registry: deps.registry,
+            resolveEndpointBase: deps.resolveEndpointBase,
+        };
+        return run(req, res, deps, () => handleBusinessChannels(req, res, installationRef, channelDeps));
+    }
     if (installationRef.action === 'grants') {
         return run(req, res, deps, () => handleBusinessGrants(req, res, installationRef, deps));
     }
+    if (installationRef.action === 'invitations') {
+        return run(req, res, deps, () => handleBusinessInvitations(req, res, installationRef, deps));
+    }
+    if (installationRef.action === 'assignees') {
+        return run(req, res, deps, () => handleEligibleBusinessAssignees(req, res, installationRef, deps));
+    }
+    if (installationRef.action === 'source') {
+        return run(req, res, deps, () => handleCollectionSource(req, res, installationRef, deps));
+    }
     if (installationRef.action === 'records' ||
         installationRef.action === 'activity' ||
         installationRef.action === 'export') {
@@ -42,7 +104,28 @@ function run(req, res, deps, handle) {
     deps.applySecurityHeaders(res, deps.tls);
     if (deps.enforceHttps(req, res, deps.tls))
         return true;
-    void handle().catch((error) => respondRouteError(deps.logger, res, 'business_information.route.failed', error));
+    void handle().catch((error) => respondBusinessError(deps, res, 'business_information.route.failed', error));
     return true;
 }
+function respondBusinessError(deps, res, event, error) {
+    if (error instanceof OrganizationAgreementError || error instanceof BusinessNoticeError) {
+        const forbidden = error.code === 'agreement_owner_required' || error.code === 'business_notice_forbidden';
+        sendJson(res, forbidden ? 403 : 409, { error: error.message, code: error.code });
+        return;
+    }
+    if (error instanceof SourceCredentialError) {
+        sendJson(res, 503, {
+            error: 'Collection source authorization changed; reconnect and replace its binding.',
+            code: 'source_unavailable',
+        });
+        return;
+    }
+    if (error instanceof NativeStorageLimitError ||
+        error instanceof SourceCapacityError ||
+        error instanceof InstallationCapacityError) {
+        sendJson(res, 409, { error: error.message, code: error.code });
+        return;
+    }
+    respondRouteError(deps.logger, res, event, error);
+}
 //# sourceMappingURL=business-information-dispatch.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-external.js

@@ -0,0 +1,79 @@
+import { sendJson } from '@noodle-borg/transport-http';
+import { CursorValidationError, } from '../business-information/portable.js';
+import { externalRecordToWire } from './business-information-wire.js';
+export function sourceBindingKey(installation, collection) {
+    return {
+        scope: installation.scope,
+        collectionKey: collection.key,
+        id: collection.key,
+    };
+}
+export async function loadExternalRecords(installation, collection, deps, paging = {}) {
+    if (deps.sourceStore === undefined)
+        return undefined;
+    const key = sourceBindingKey(installation, collection);
+    const binding = await deps.sourceStore.getBinding(key);
+    if (binding === undefined)
+        return undefined;
+    if (binding.state === 'revoked' || binding.health === 'reauth_required')
+        return undefined;
+    const page = await deps.sourceStore.listExternalRecords({
+        ...key,
+        generation: binding.generation,
+        ...paging,
+    });
+    return { binding, ...page };
+}
+export async function loadExternalRecord(installation, collection, recordId, deps) {
+    if (deps.sourceStore === undefined)
+        return undefined;
+    const key = sourceBindingKey(installation, collection);
+    const binding = await deps.sourceStore.getBinding(key);
+    if (binding === undefined ||
+        binding.state === 'revoked' ||
+        binding.health === 'reauth_required') {
+        return undefined;
+    }
+    const record = await deps.sourceStore.getExternalRecord({
+        ...key,
+        generation: binding.generation,
+        recordId,
+    });
+    return { binding, record };
+}
+export async function sendExternalRecordPage(res, installation, collection, paging, deps) {
+    let loaded;
+    try {
+        loaded = await loadExternalRecords(installation, collection, deps, paging);
+    }
+    catch (error) {
+        if (!(error instanceof CursorValidationError))
+            throw error;
+        sendJson(res, 400, { error: 'cursor is invalid', code: 'invalid_cursor' });
+        return;
+    }
+    if (loaded === undefined) {
+        sendJson(res, 503, {
+            error: 'collection source is not configured or unavailable',
+            code: 'source_unavailable',
+        });
+        return;
+    }
+    sendJson(res, 200, {
+        ok: true,
+        data: {
+            records: loaded.records.map((record) => externalRecordToWire(record, loaded.binding)),
+            ...(loaded.nextCursor === undefined ? {} : { nextCursor: loaded.nextCursor }),
+        },
+    });
+}
+export function unsupportedExternalOperation(res, operation) {
+    const normalized = operation === 'set-status' ? 'set-status' : operation;
+    sendJson(res, 405, {
+        ok: false,
+        error: 'externally authoritative collections are read-only replicas; use an application tool for source changes',
+        code: 'operation_not_supported',
+        details: { authority: 'external', operation: normalized },
+    });
+}
+//# sourceMappingURL=business-information-external.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-installation.js

@@ -0,0 +1,24 @@
+import { createHash } from 'node:crypto';
+import { builtInDefinition, } from '../business-information/portable.js';
+export function stableInstallationId(org, app, env) {
+    return `ins-${createHash('sha256').update(`${org}\0${app}\0${env}`).digest('hex').slice(0, 24)}`;
+}
+export async function resolveInstallDefinition(selector, installingOrg, resolvePrivateDefinition) {
+    if (selector.kind === 'managed') {
+        return builtInDefinition(selector.profileId);
+    }
+    if (selector.publisherOrg !== installingOrg ||
+        selector.publisherOrg === undefined ||
+        selector.app === undefined ||
+        selector.environment === undefined ||
+        selector.deploymentId === undefined) {
+        return undefined;
+    }
+    return resolvePrivateDefinition?.({
+        publisherOrg: selector.publisherOrg,
+        app: selector.app,
+        environment: selector.environment,
+        deploymentId: selector.deploymentId,
+    });
+}
+//# sourceMappingURL=business-information-installation.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-notice.js

@@ -0,0 +1,69 @@
+import { readJsonBody, sendJson } from '@noodle-borg/transport-http';
+import { BusinessNoticeResponseSchema, BusinessNoticeSaveRequestSchema, OrganizationAgreementAcceptRequestSchema, OrganizationAgreementResponseSchema, } from '@noodle-borg/wire-contracts';
+import { admitBusinessTarget } from '../business-api-admission.js';
+import { sendForbidden } from '../http-util.js';
+import { invalid, methodNotAllowed, requireIdentity, requireInstallationGrant, requireInstallationPermission, } from './business-information.js';
+import { canManageMembers } from './org-admin.js';
+export async function handleOrganizationAgreement(req, res, org, deps) {
+    if (req.method !== 'GET' && req.method !== 'POST')
+        return methodNotAllowed(res);
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    if (!(await canManageMembers(deps.controlPlane, org, identity)))
+        return sendForbidden(res, 'organization owner required');
+    if (!(await admitBusinessTarget(res, { org })))
+        return;
+    const onboarding = deps.businessOnboarding;
+    if (!onboarding)
+        return sendJson(res, 503, {
+            code: 'business_setup_unavailable',
+            error: 'Business agreement configuration is unavailable.',
+        });
+    let status = await onboarding.status(org, identity.subject);
+    if (req.method === 'POST') {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = OrganizationAgreementAcceptRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res, parsed.error);
+        status = await onboarding.accept(org, identity.subject, parsed.data);
+    }
+    return sendJson(res, 200, OrganizationAgreementResponseSchema.parse({ ok: true, data: status }));
+}
+export async function handleBusinessNotice(req, res, ref, deps) {
+    if (req.method !== 'GET' && req.method !== 'PUT')
+        return methodNotAllowed(res);
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const authorized = req.method === 'PUT'
+        ? await requireInstallationPermission(res, ref, identity, 'installation:administer', deps)
+        : await requireInstallationGrant(res, ref, identity, deps);
+    if (!authorized)
+        return;
+    let record = await deps.store.getBusinessNotice(authorized.scope);
+    if (req.method === 'PUT') {
+        const body = await readJsonBody(req, deps.maxBody);
+        if (!body.ok)
+            return sendJson(res, body.status, { error: body.error });
+        const parsed = BusinessNoticeSaveRequestSchema.safeParse(body.value);
+        if (!parsed.success)
+            return invalid(res, parsed.error);
+        record = await deps.store.setBusinessNotice({
+            scope: authorized.scope,
+            ...parsed.data,
+            actorSubject: identity.subject,
+        });
+    }
+    return sendJson(res, 200, BusinessNoticeResponseSchema.parse({
+        ok: true,
+        data: {
+            revision: record?.revision ?? 0,
+            notice: record?.notice ?? null,
+            canEdit: authorized.grant.role === 'administrator',
+        },
+    }));
+}
+//# sourceMappingURL=business-information-notice.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-onboarding.js

@@ -0,0 +1,58 @@
+import { sendJson } from '@noodle-borg/transport-http';
+import { SolutionInstallationOptionsQuerySchema, SolutionInstallationOptionsResponseSchema, } from '@noodle-borg/wire-contracts';
+import { requireIdentity } from './business-information.js';
+import { canManageMembers } from './org-admin.js';
+/** Installation permission only. Deployment still owns transactional capacity admission. */
+export async function handleSolutionInstallationOptions(req, res, deps) {
+    if (req.method !== 'GET') {
+        res.setHeader('allow', 'GET');
+        return sendJson(res, 405, { error: 'method not allowed' });
+    }
+    const identity = await requireIdentity(req, res, deps);
+    if (identity === false)
+        return;
+    const params = new URL(req.url ?? '/', 'http://service.invalid').searchParams;
+    const parsed = SolutionInstallationOptionsQuerySchema.safeParse(Object.fromEntries(params));
+    if (!parsed.success || [...params.keys()].some((key) => params.getAll(key).length !== 1))
+        return sendJson(res, 400, {
+            error: 'invalid installation options query',
+            code: 'invalid_query',
+        });
+    const { cursor, limit } = parsed.data;
+    const after = cursor === undefined ? undefined : Buffer.from(cursor, 'base64url').toString('utf8');
+    if (after !== undefined &&
+        (!/^[a-z][a-z0-9-]{0,99}$/.test(after) || Buffer.from(after).toString('base64url') !== cursor))
+        return sendJson(res, 400, {
+            error: 'invalid installation options cursor',
+            code: 'invalid_query',
+        });
+    const organizations = identity.superAdmin
+        ? await deps.controlPlane.listOrgs()
+        : await deps.controlPlane.listOrgsForSubject(identity.subject);
+    const eligible = [];
+    for (const organization of [...organizations].sort((left, right) => left.slug < right.slug ? -1 : left.slug > right.slug ? 1 : 0)) {
+        if (after !== undefined && organization.slug <= after)
+            continue;
+        if (!(await canManageMembers(deps.controlPlane, organization.slug, identity)))
+            continue;
+        eligible.push({
+            slug: organization.slug,
+            ...(organization.displayName === undefined ? {} : { displayName: organization.displayName }),
+        });
+        if (eligible.length > limit)
+            break;
+    }
+    const page = eligible.slice(0, limit);
+    const last = page.at(-1);
+    res.setHeader('cache-control', 'no-store');
+    sendJson(res, 200, SolutionInstallationOptionsResponseSchema.parse({
+        ok: true,
+        data: {
+            organizations: page,
+            ...(eligible.length > limit && last !== undefined
+                ? { nextCursor: Buffer.from(last.slug).toString('base64url') }
+                : {}),
+        },
+    }));
+}
+//# sourceMappingURL=business-information-onboarding.js.map

package/node_modules/@noodle-borg/service/dist/routes/business-information-paths.js

@@ -11,6 +11,36 @@ function decoded(match, index) {
     }
 }
 export function parseSolutionInstallationPath(pathname) {
+    const connection = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/connections(?:\/([^/]+)\/(connect|disconnect))?$/.exec(pathname);
+    if (connection !== null) {
+        const org = decoded(connection, 1), installationId = decoded(connection, 2), connectionId = decoded(connection, 3);
+        const connectionAction = connection[4];
+        return org === undefined ||
+            installationId === undefined ||
+            (connectionAction !== undefined && connectionId === undefined)
+            ? undefined
+            : {
+                org,
+                installationId,
+                action: 'connections',
+                ...(connectionId === undefined ? {} : { connectionId }),
+                ...(connectionAction === undefined ? {} : { connectionAction }),
+            };
+    }
+    const application = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/(settings|notice|channels|activity(?:\/(?:settings|export|preview))?)$/.exec(pathname);
+    if (application !== null) {
+        const org = decoded(application, 1);
+        const installationId = decoded(application, 2);
+        return org === undefined || installationId === undefined
+            ? undefined
+            : {
+                org,
+                installationId,
+                action: application[3]?.startsWith('activity')
+                    ? 'activity'
+                    : application[3],
+            };
+    }
     let match = /^\/v1\/orgs\/([^/]+)\/solution-installations$/.exec(pathname);
     if (match !== null) {
         const org = decoded(match, 1);
@@ -39,6 +69,48 @@ export function parseSolutionInstallationPath(pathname) {
             ? undefined
             : { org, installationId, subject, action: 'grants' };
     }
+    match = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/invitations$/.exec(pathname);
+    if (match !== null) {
+        const org = decoded(match, 1);
+        const installationId = decoded(match, 2);
+        return org === undefined || installationId === undefined
+            ? undefined
+            : { org, installationId, action: 'invitations' };
+    }
+    match = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/invitations\/([^/]+)$/.exec(pathname);
+    if (match !== null) {
+        const org = decoded(match, 1);
+        const installationId = decoded(match, 2);
+        const invitationId = decoded(match, 3);
+        return org === undefined || installationId === undefined || invitationId === undefined
+            ? undefined
+            : { org, installationId, invitationId, action: 'invitations' };
+    }
+    match = /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/assignees$/.exec(pathname);
+    if (match !== null) {
+        const org = decoded(match, 1);
+        const installationId = decoded(match, 2);
+        return org === undefined || installationId === undefined
+            ? undefined
+            : { org, installationId, action: 'assignees' };
+    }
+    match =
+        /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/collections\/([^/]+)\/source(?:\/(pause|resume|refresh))?$/.exec(pathname);
+    if (match !== null) {
+        const org = decoded(match, 1);
+        const installationId = decoded(match, 2);
+        const collection = decoded(match, 3);
+        const sourceAction = match[4];
+        return org === undefined || installationId === undefined || collection === undefined
+            ? undefined
+            : {
+                org,
+                installationId,
+                collection,
+                action: 'source',
+                ...(sourceAction === undefined ? {} : { sourceAction }),
+            };
+    }
     match =
         /^\/v1\/orgs\/([^/]+)\/solution-installations\/([^/]+)\/collections\/([^/]+)\/records(?:\/(export))?$/.exec(pathname);
     if (match !== null) {
@@ -76,6 +148,10 @@ export function parseSolutionInstallationPath(pathname) {
     }
     return undefined;
 }
+export function parseSolutionInvitationAcceptPath(pathname) {
+    const match = /^\/v1\/solution-invitations\/([^/]+)\/accept$/.exec(pathname);
+    return match === null ? undefined : decoded(match, 1);
+}
 export function parsePublicSolutionIntakePath(pathname) {
     let match = /^\/v1\/solution-intake\/([^/]+)$/.exec(pathname);
     if (match !== null) {