@claudian-collab/protocol 3.2.1 → 3.3.1

package/dist/esm/CollabProjectMembership.mjs

@@ -0,0 +1,709 @@
+import { COLLAB_MEMBER_REF_PREFIX } from './CollabConstants.mjs';
+import { CollabError } from './CollabError.mjs';
+import { hasUtf8ByteLengthAtMost, isCollabGitOid, isCollabMemberId, isCollabOpaqueId, isCollabProjectId, } from './CollabValidation.mjs';
+export const COLLAB_PROJECT_MEMBERSHIP_LIMITS = Object.freeze({
+    invitationSecretLength: 43,
+    invitationTtlMs: 86_400_000,
+    managerResponsibilityOfferRetentionMs: 2_592_000_000,
+    managerResponsibilityOfferTtlMs: 86_400_000,
+    maxCurrentManagerOffers: 100,
+    maxDisplayNameUtf8Bytes: 128,
+    maxProjectInvitations: 100,
+    maxProjectMembers: 100,
+    maxProjectNameUtf8Bytes: 256,
+    secretReplayTtlMs: 2_592_000_000,
+    transferredClaimLength: 43,
+    transferredClaimTtlMs: 2_592_000_000,
+});
+export const COLLAB_PROJECT_MEMBERSHIP_OPERATIONS = Object.freeze([
+    'createCloudProject',
+    'createProjectInvitation',
+    'listProjectInvitations',
+    'revokeProjectInvitation',
+    'joinCloudProject',
+    'listProjectMembers',
+    'reissueTransferredMembershipClaim',
+    'revokeTransferredMembershipClaim',
+    'createManagerResponsibilityOffer',
+    'listCurrentManagerResponsibilityOffers',
+    'getManagerResponsibilityOffer',
+    'acknowledgeManagerResponsibility',
+    'declineManagerResponsibility',
+    'cancelManagerResponsibilityOffer',
+    'promoteManager',
+    'demoteManager',
+    'removeMember',
+    'leaveProject',
+]);
+function invalidPayload(field) {
+    return new CollabError({ code: 'protocol-payload-invalid', safeContext: { field } });
+}
+function exactRecord(value, field, keys) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw invalidPayload(field);
+    }
+    const source = value;
+    const expected = new Set(keys);
+    if (!keys.every(key => Object.hasOwn(source, key))
+        || Object.keys(source).some(key => !expected.has(key)))
+        throw invalidPayload(field);
+    return source;
+}
+function token(source, field, validate = isCollabOpaqueId) {
+    const value = source[field];
+    if (typeof value !== 'string' || !validate(value))
+        throw invalidPayload(field);
+    return value;
+}
+function boundedText(source, field, maximum) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || value.length === 0
+        || value.includes('\u0000')
+        || !hasUtf8ByteLengthAtMost(value, maximum))
+        throw invalidPayload(field);
+    return value;
+}
+function positiveInteger(source, field) {
+    const value = source[field];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function nonNegativeInteger(source, field) {
+    const value = source[field];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function literal(source, field, values) {
+    const value = source[field];
+    if (typeof value !== 'string' || !values.includes(value)) {
+        throw invalidPayload(field);
+    }
+    return value;
+}
+function timestamp(source, field) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || value.length > 64
+        || Number.isNaN(Date.parse(value))
+        || new Date(value).toISOString() !== value)
+        throw invalidPayload(field);
+    return value;
+}
+function hasExactDuration(start, end, durationMs) {
+    return Date.parse(end) === Date.parse(start) + durationMs;
+}
+function nullableTimestamp(source, field) {
+    return source[field] === null ? null : timestamp(source, field);
+}
+function nullableToken(source, field, validate = isCollabOpaqueId) {
+    return source[field] === null ? null : token(source, field, validate);
+}
+function secret(source, field, exactLength) {
+    const value = source[field];
+    if (typeof value !== 'string'
+        || value.length !== exactLength
+        || !/^[A-Za-z0-9_-]{42}[AEIMQUYcgkosw048]$/u.test(value))
+        throw invalidPayload(field);
+    return value;
+}
+function projectFields(source) {
+    return { projectId: token(source, 'projectId', isCollabProjectId) };
+}
+function mutationFields(source) {
+    return {
+        idempotencyKey: token(source, 'idempotencyKey'),
+        ...projectFields(source),
+    };
+}
+function personalRef(source, memberId) {
+    const value = token(source, 'personalRef', value => typeof value === 'string');
+    if (value !== `${COLLAB_MEMBER_REF_PREFIX}${memberId}`)
+        throw invalidPayload('personalRef');
+    return value;
+}
+function decodeProjectRequest(value) {
+    return projectFields(exactRecord(value, 'request', ['projectId']));
+}
+function decodeCreateCloudProjectRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'idempotencyKey',
+        'managerDisplayName',
+        'projectId',
+        'projectName',
+    ]);
+    return {
+        ...mutationFields(source),
+        managerDisplayName: boundedText(source, 'managerDisplayName', COLLAB_PROJECT_MEMBERSHIP_LIMITS.maxDisplayNameUtf8Bytes),
+        projectName: boundedText(source, 'projectName', COLLAB_PROJECT_MEMBERSHIP_LIMITS.maxProjectNameUtf8Bytes),
+    };
+}
+function decodeCreateCloudProjectResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'createdAt',
+        'mainOid',
+        'managerSetGeneration',
+        'memberId',
+        'membershipRevision',
+        'personalRef',
+        'projectId',
+        'role',
+    ]);
+    const memberId = token(source, 'memberId', isCollabMemberId);
+    if (source.managerSetGeneration !== 1
+        || source.membershipRevision !== 2
+        || source.role !== 'manager')
+        throw invalidPayload('response');
+    return {
+        createdAt: timestamp(source, 'createdAt'),
+        mainOid: token(source, 'mainOid', isCollabGitOid),
+        managerSetGeneration: 1,
+        memberId,
+        membershipRevision: 2,
+        personalRef: personalRef(source, memberId),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        role: 'manager',
+    };
+}
+function decodeCreateInvitationRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedManagerSetGeneration',
+        'idempotencyKey',
+        'projectId',
+    ]);
+    return {
+        expectedManagerSetGeneration: positiveInteger(source, 'expectedManagerSetGeneration'),
+        ...mutationFields(source),
+    };
+}
+function decodeCreateInvitationResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'createdAt',
+        'expiresAt',
+        'invitationId',
+        'issuedState',
+        'projectId',
+        'secret',
+        'secretReplayExpiresAt',
+    ]);
+    const createdAt = timestamp(source, 'createdAt');
+    const expiresAt = timestamp(source, 'expiresAt');
+    const secretReplayExpiresAt = timestamp(source, 'secretReplayExpiresAt');
+    if (source.issuedState !== 'active'
+        || !hasExactDuration(createdAt, expiresAt, COLLAB_PROJECT_MEMBERSHIP_LIMITS.invitationTtlMs)
+        || !hasExactDuration(createdAt, secretReplayExpiresAt, COLLAB_PROJECT_MEMBERSHIP_LIMITS.secretReplayTtlMs))
+        throw invalidPayload('response');
+    return {
+        createdAt,
+        expiresAt,
+        invitationId: token(source, 'invitationId'),
+        issuedState: 'active',
+        projectId: token(source, 'projectId', isCollabProjectId),
+        secret: secret(source, 'secret', COLLAB_PROJECT_MEMBERSHIP_LIMITS.invitationSecretLength),
+        secretReplayExpiresAt,
+    };
+}
+function decodeInvitationSummary(value) {
+    const source = exactRecord(value, 'invitation', [
+        'createdAt',
+        'expiresAt',
+        'invitationId',
+        'revision',
+        'state',
+        'terminalAt',
+    ]);
+    const state = literal(source, 'state', [
+        'active',
+        'redeeming',
+        'redeemed',
+        'revoked',
+        'expired',
+    ]);
+    const createdAt = timestamp(source, 'createdAt');
+    const expiresAt = timestamp(source, 'expiresAt');
+    const terminalAt = nullableTimestamp(source, 'terminalAt');
+    const terminal = state === 'redeemed' || state === 'revoked' || state === 'expired';
+    if (!hasExactDuration(createdAt, expiresAt, COLLAB_PROJECT_MEMBERSHIP_LIMITS.invitationTtlMs)
+        || terminal !== (terminalAt !== null)
+        || (terminalAt !== null && Date.parse(terminalAt) < Date.parse(createdAt)))
+        throw invalidPayload('invitation');
+    return {
+        createdAt,
+        expiresAt,
+        invitationId: token(source, 'invitationId'),
+        revision: positiveInteger(source, 'revision'),
+        state,
+        terminalAt,
+    };
+}
+function decodeListInvitationsResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'invitations',
+        'managerSetGeneration',
+        'projectId',
+    ]);
+    if (!Array.isArray(source.invitations)
+        || source.invitations.length > COLLAB_PROJECT_MEMBERSHIP_LIMITS.maxProjectInvitations)
+        throw invalidPayload('invitations');
+    return {
+        invitations: source.invitations.map(decodeInvitationSummary),
+        managerSetGeneration: positiveInteger(source, 'managerSetGeneration'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+    };
+}
+function decodeRevokeInvitationRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedInvitationRevision',
+        'expectedManagerSetGeneration',
+        'idempotencyKey',
+        'invitationId',
+        'projectId',
+    ]);
+    return {
+        expectedInvitationRevision: positiveInteger(source, 'expectedInvitationRevision'),
+        expectedManagerSetGeneration: positiveInteger(source, 'expectedManagerSetGeneration'),
+        ...mutationFields(source),
+        invitationId: token(source, 'invitationId'),
+    };
+}
+function decodeRevokeInvitationResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'invitationId',
+        'projectId',
+        'revision',
+        'revokedAt',
+        'state',
+    ]);
+    if (source.state !== 'revoked')
+        throw invalidPayload('state');
+    return {
+        invitationId: token(source, 'invitationId'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        revision: positiveInteger(source, 'revision'),
+        revokedAt: timestamp(source, 'revokedAt'),
+        state: 'revoked',
+    };
+}
+function decodeJoinRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'displayName',
+        'idempotencyKey',
+        'invitationId',
+        'projectId',
+        'secret',
+    ]);
+    return {
+        displayName: boundedText(source, 'displayName', COLLAB_PROJECT_MEMBERSHIP_LIMITS.maxDisplayNameUtf8Bytes),
+        ...mutationFields(source),
+        invitationId: token(source, 'invitationId'),
+        secret: secret(source, 'secret', COLLAB_PROJECT_MEMBERSHIP_LIMITS.invitationSecretLength),
+    };
+}
+function decodeJoinResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'joinedAt',
+        'mainOid',
+        'managerSetGeneration',
+        'memberId',
+        'membershipRevision',
+        'personalRef',
+        'projectId',
+        'role',
+    ]);
+    const memberId = token(source, 'memberId', isCollabMemberId);
+    if (source.membershipRevision !== 2 || source.role !== 'member') {
+        throw invalidPayload('response');
+    }
+    return {
+        joinedAt: timestamp(source, 'joinedAt'),
+        mainOid: token(source, 'mainOid', isCollabGitOid),
+        managerSetGeneration: positiveInteger(source, 'managerSetGeneration'),
+        memberId,
+        membershipRevision: 2,
+        personalRef: personalRef(source, memberId),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        role: 'member',
+    };
+}
+function decodeMemberSummary(value) {
+    const source = exactRecord(value, 'member', [
+        'bindingState',
+        'displayName',
+        'importedClaimState',
+        'memberId',
+        'membershipRevision',
+        'role',
+    ]);
+    return {
+        bindingState: literal(source, 'bindingState', ['bound', 'unbound', 'hidden']),
+        displayName: boundedText(source, 'displayName', COLLAB_PROJECT_MEMBERSHIP_LIMITS.maxDisplayNameUtf8Bytes),
+        importedClaimState: literal(source, 'importedClaimState', [
+            'not-applicable',
+            'original-active',
+            'override-active',
+            'revoked',
+            'expired',
+            'redeemed',
+            'hidden',
+        ]),
+        memberId: token(source, 'memberId', isCollabMemberId),
+        membershipRevision: positiveInteger(source, 'membershipRevision'),
+        role: literal(source, 'role', ['manager', 'member']),
+    };
+}
+function decodeListMembersResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'managerSetGeneration',
+        'members',
+        'projectId',
+    ]);
+    if (!Array.isArray(source.members)
+        || source.members.length > COLLAB_PROJECT_MEMBERSHIP_LIMITS.maxProjectMembers)
+        throw invalidPayload('members');
+    return {
+        managerSetGeneration: positiveInteger(source, 'managerSetGeneration'),
+        members: source.members.map(decodeMemberSummary),
+        projectId: token(source, 'projectId', isCollabProjectId),
+    };
+}
+function decodeClaimMutationRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedClaimGeneration',
+        'expectedManagerSetGeneration',
+        'expectedMembershipRevision',
+        'idempotencyKey',
+        'memberId',
+        'projectId',
+    ]);
+    return {
+        expectedClaimGeneration: nonNegativeInteger(source, 'expectedClaimGeneration'),
+        expectedManagerSetGeneration: positiveInteger(source, 'expectedManagerSetGeneration'),
+        expectedMembershipRevision: positiveInteger(source, 'expectedMembershipRevision'),
+        ...mutationFields(source),
+        memberId: token(source, 'memberId', isCollabMemberId),
+    };
+}
+function decodeReissueClaimResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'claim',
+        'claimGeneration',
+        'createdAt',
+        'expiresAt',
+        'memberId',
+        'projectId',
+        'secretReplayExpiresAt',
+    ]);
+    const createdAt = timestamp(source, 'createdAt');
+    const expiresAt = timestamp(source, 'expiresAt');
+    const secretReplayExpiresAt = timestamp(source, 'secretReplayExpiresAt');
+    if (!hasExactDuration(createdAt, expiresAt, COLLAB_PROJECT_MEMBERSHIP_LIMITS.transferredClaimTtlMs)
+        || !hasExactDuration(createdAt, secretReplayExpiresAt, COLLAB_PROJECT_MEMBERSHIP_LIMITS.secretReplayTtlMs))
+        throw invalidPayload('response');
+    return {
+        claim: secret(source, 'claim', COLLAB_PROJECT_MEMBERSHIP_LIMITS.transferredClaimLength),
+        claimGeneration: positiveInteger(source, 'claimGeneration'),
+        createdAt,
+        expiresAt,
+        memberId: token(source, 'memberId', isCollabMemberId),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        secretReplayExpiresAt,
+    };
+}
+function decodeRevokeClaimResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'claimGeneration',
+        'memberId',
+        'projectId',
+        'revokedAt',
+        'state',
+    ]);
+    if (source.state !== 'revoked')
+        throw invalidPayload('state');
+    return {
+        claimGeneration: nonNegativeInteger(source, 'claimGeneration'),
+        memberId: token(source, 'memberId', isCollabMemberId),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        revokedAt: timestamp(source, 'revokedAt'),
+        state: 'revoked',
+    };
+}
+function decodeOffer(value) {
+    const source = exactRecord(value, 'offer', [
+        'acknowledgedAt',
+        'expiresAt',
+        'managerSetGenerationAtOffer',
+        'offeredAt',
+        'offerId',
+        'purpose',
+        'revision',
+        'sourceManagerMemberId',
+        'state',
+        'targetMemberId',
+        'targetMembershipRevisionAtOffer',
+        'terminalAt',
+    ]);
+    const state = literal(source, 'state', [
+        'offered',
+        'acknowledged',
+        'declined',
+        'cancelled',
+        'consumed',
+        'expired',
+    ]);
+    const offeredAt = timestamp(source, 'offeredAt');
+    const expiresAt = timestamp(source, 'expiresAt');
+    const acknowledgedAt = nullableTimestamp(source, 'acknowledgedAt');
+    const terminalAt = nullableTimestamp(source, 'terminalAt');
+    const isTerminal = ['declined', 'cancelled', 'consumed', 'expired'].includes(state);
+    if (!hasExactDuration(offeredAt, expiresAt, COLLAB_PROJECT_MEMBERSHIP_LIMITS.managerResponsibilityOfferTtlMs)
+        || (state === 'offered' && acknowledgedAt !== null)
+        || (state === 'acknowledged' && acknowledgedAt === null)
+        || isTerminal !== (terminalAt !== null)
+        || (acknowledgedAt !== null && Date.parse(acknowledgedAt) < Date.parse(offeredAt))
+        || (terminalAt !== null && Date.parse(terminalAt) < Date.parse(offeredAt)))
+        throw invalidPayload('offer');
+    return {
+        acknowledgedAt,
+        expiresAt,
+        managerSetGenerationAtOffer: positiveInteger(source, 'managerSetGenerationAtOffer'),
+        offeredAt,
+        offerId: token(source, 'offerId'),
+        purpose: literal(source, 'purpose', ['manager-promotion', 'manager-leave']),
+        revision: positiveInteger(source, 'revision'),
+        sourceManagerMemberId: token(source, 'sourceManagerMemberId', isCollabMemberId),
+        state,
+        targetMemberId: token(source, 'targetMemberId', isCollabMemberId),
+        targetMembershipRevisionAtOffer: positiveInteger(source, 'targetMembershipRevisionAtOffer'),
+        terminalAt,
+    };
+}
+function decodeOfferResponse(value) {
+    const source = exactRecord(value, 'response', ['offer']);
+    return { offer: decodeOffer(source.offer) };
+}
+function decodeCreateOfferRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedManagerSetGeneration',
+        'expectedTargetMembershipRevision',
+        'idempotencyKey',
+        'projectId',
+        'purpose',
+        'targetMemberId',
+    ]);
+    return {
+        expectedManagerSetGeneration: positiveInteger(source, 'expectedManagerSetGeneration'),
+        expectedTargetMembershipRevision: positiveInteger(source, 'expectedTargetMembershipRevision'),
+        ...mutationFields(source),
+        purpose: literal(source, 'purpose', ['manager-promotion', 'manager-leave']),
+        targetMemberId: token(source, 'targetMemberId', isCollabMemberId),
+    };
+}
+function decodeListOffersResponse(value) {
+    const source = exactRecord(value, 'response', ['offers', 'projectId']);
+    if (!Array.isArray(source.offers)
+        || source.offers.length > COLLAB_PROJECT_MEMBERSHIP_LIMITS.maxCurrentManagerOffers)
+        throw invalidPayload('offers');
+    const offers = source.offers.map(decodeOffer);
+    if (offers.some(item => item.state !== 'offered' && item.state !== 'acknowledged')
+        || offers.some((item, index) => (index > 0 && offers[index - 1].offerId.localeCompare(item.offerId, 'en-US') >= 0)))
+        throw invalidPayload('offers');
+    return {
+        offers,
+        projectId: token(source, 'projectId', isCollabProjectId),
+    };
+}
+function decodeGetOfferRequest(value) {
+    const source = exactRecord(value, 'request', ['offerId', 'projectId']);
+    return { offerId: token(source, 'offerId'), ...projectFields(source) };
+}
+function decodeTransitionOfferRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedOfferRevision',
+        'idempotencyKey',
+        'offerId',
+        'projectId',
+    ]);
+    return {
+        expectedOfferRevision: positiveInteger(source, 'expectedOfferRevision'),
+        ...mutationFields(source),
+        offerId: token(source, 'offerId'),
+    };
+}
+function decodePromoteRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedManagerSetGeneration',
+        'expectedOfferRevision',
+        'expectedTargetMembershipRevision',
+        'idempotencyKey',
+        'managerResponsibilityOfferId',
+        'projectId',
+        'targetMemberId',
+    ]);
+    return {
+        expectedManagerSetGeneration: positiveInteger(source, 'expectedManagerSetGeneration'),
+        expectedOfferRevision: positiveInteger(source, 'expectedOfferRevision'),
+        expectedTargetMembershipRevision: positiveInteger(source, 'expectedTargetMembershipRevision'),
+        ...mutationFields(source),
+        managerResponsibilityOfferId: token(source, 'managerResponsibilityOfferId'),
+        targetMemberId: token(source, 'targetMemberId', isCollabMemberId),
+    };
+}
+function decodePromoteResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'managerSetGeneration',
+        'membershipRevision',
+        'offerRevision',
+        'projectId',
+        'promotedMemberId',
+    ]);
+    return {
+        managerSetGeneration: positiveInteger(source, 'managerSetGeneration'),
+        membershipRevision: positiveInteger(source, 'membershipRevision'),
+        offerRevision: positiveInteger(source, 'offerRevision'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        promotedMemberId: token(source, 'promotedMemberId', isCollabMemberId),
+    };
+}
+function decodeTargetRoleRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedManagerSetGeneration',
+        'expectedTargetMembershipRevision',
+        'idempotencyKey',
+        'projectId',
+        'targetMemberId',
+    ]);
+    return {
+        expectedManagerSetGeneration: positiveInteger(source, 'expectedManagerSetGeneration'),
+        expectedTargetMembershipRevision: positiveInteger(source, 'expectedTargetMembershipRevision'),
+        ...mutationFields(source),
+        targetMemberId: token(source, 'targetMemberId', isCollabMemberId),
+    };
+}
+function decodeDemoteResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'demotedMemberId',
+        'managerSetGeneration',
+        'membershipRevision',
+        'projectId',
+    ]);
+    return {
+        demotedMemberId: token(source, 'demotedMemberId', isCollabMemberId),
+        managerSetGeneration: positiveInteger(source, 'managerSetGeneration'),
+        membershipRevision: positiveInteger(source, 'membershipRevision'),
+        projectId: token(source, 'projectId', isCollabProjectId),
+    };
+}
+function decodeRemoveResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'discardedRequestId',
+        'managerSetGeneration',
+        'memberId',
+        'projectId',
+        'removedAt',
+        'status',
+    ]);
+    if (source.status !== 'revoked')
+        throw invalidPayload('status');
+    return {
+        discardedRequestId: nullableToken(source, 'discardedRequestId'),
+        managerSetGeneration: positiveInteger(source, 'managerSetGeneration'),
+        memberId: token(source, 'memberId', isCollabMemberId),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        removedAt: timestamp(source, 'removedAt'),
+        status: 'revoked',
+    };
+}
+function decodeLeaveRequest(value) {
+    const source = exactRecord(value, 'request', [
+        'expectedManagerSetGeneration',
+        'expectedMembershipRevision',
+        'expectedOfferRevision',
+        'expectedPersonalRefOid',
+        'idempotencyKey',
+        'managerResponsibilityOfferId',
+        'projectId',
+    ]);
+    const managerResponsibilityOfferId = nullableToken(source, 'managerResponsibilityOfferId');
+    const expectedOfferRevision = source.expectedOfferRevision === null
+        ? null
+        : positiveInteger(source, 'expectedOfferRevision');
+    if ((managerResponsibilityOfferId === null) !== (expectedOfferRevision === null)) {
+        throw invalidPayload('managerResponsibilityOfferId');
+    }
+    return {
+        expectedManagerSetGeneration: positiveInteger(source, 'expectedManagerSetGeneration'),
+        expectedMembershipRevision: positiveInteger(source, 'expectedMembershipRevision'),
+        expectedOfferRevision,
+        expectedPersonalRefOid: token(source, 'expectedPersonalRefOid', isCollabGitOid),
+        ...mutationFields(source),
+        managerResponsibilityOfferId,
+    };
+}
+function decodeLeaveResponse(value) {
+    const source = exactRecord(value, 'response', [
+        'discardedRequestId',
+        'leftAt',
+        'managerSetGeneration',
+        'memberId',
+        'projectId',
+        'promotedSuccessorMemberId',
+        'status',
+    ]);
+    if (source.status !== 'left')
+        throw invalidPayload('status');
+    return {
+        discardedRequestId: nullableToken(source, 'discardedRequestId'),
+        leftAt: timestamp(source, 'leftAt'),
+        managerSetGeneration: positiveInteger(source, 'managerSetGeneration'),
+        memberId: token(source, 'memberId', isCollabMemberId),
+        projectId: token(source, 'projectId', isCollabProjectId),
+        promotedSuccessorMemberId: nullableToken(source, 'promotedSuccessorMemberId', isCollabMemberId),
+        status: 'left',
+    };
+}
+function codec(decodeRequestValue, decodeResponse) {
+    return Object.freeze({
+        decodeRequest: (input) => {
+            try {
+                return { status: 'ok', value: decodeRequestValue(input) };
+            }
+            catch (error) {
+                if (error instanceof CollabError && error.code === 'protocol-payload-invalid') {
+                    return { error, status: 'invalid' };
+                }
+                throw error;
+            }
+        },
+        decodeResponse,
+    });
+}
+export const COLLAB_PROJECT_MEMBERSHIP_OPERATION_CODECS = Object.freeze({
+    createCloudProject: codec(decodeCreateCloudProjectRequest, decodeCreateCloudProjectResponse),
+    createProjectInvitation: codec(decodeCreateInvitationRequest, decodeCreateInvitationResponse),
+    listProjectInvitations: codec(decodeProjectRequest, decodeListInvitationsResponse),
+    revokeProjectInvitation: codec(decodeRevokeInvitationRequest, decodeRevokeInvitationResponse),
+    joinCloudProject: codec(decodeJoinRequest, decodeJoinResponse),
+    listProjectMembers: codec(decodeProjectRequest, decodeListMembersResponse),
+    reissueTransferredMembershipClaim: codec(decodeClaimMutationRequest, decodeReissueClaimResponse),
+    revokeTransferredMembershipClaim: codec(decodeClaimMutationRequest, decodeRevokeClaimResponse),
+    createManagerResponsibilityOffer: codec(decodeCreateOfferRequest, decodeOfferResponse),
+    listCurrentManagerResponsibilityOffers: codec(decodeProjectRequest, decodeListOffersResponse),
+    getManagerResponsibilityOffer: codec(decodeGetOfferRequest, decodeOfferResponse),
+    acknowledgeManagerResponsibility: codec(decodeTransitionOfferRequest, decodeOfferResponse),
+    declineManagerResponsibility: codec(decodeTransitionOfferRequest, decodeOfferResponse),
+    cancelManagerResponsibilityOffer: codec(decodeTransitionOfferRequest, decodeOfferResponse),
+    promoteManager: codec(decodePromoteRequest, decodePromoteResponse),
+    demoteManager: codec(decodeTargetRoleRequest, decodeDemoteResponse),
+    removeMember: codec(decodeTargetRoleRequest, decodeRemoveResponse),
+    leaveProject: codec(decodeLeaveRequest, decodeLeaveResponse),
+});
+export function decodeCollabProjectMembershipOperationRequest(operation, value) {
+    return COLLAB_PROJECT_MEMBERSHIP_OPERATION_CODECS[operation].decodeRequest(value);
+}
+export function decodeCollabProjectMembershipOperationResponse(operation, value) {
+    return COLLAB_PROJECT_MEMBERSHIP_OPERATION_CODECS[operation].decodeResponse(value);
+}