@api-client/core 0.20.10 → 0.21.0

package/tests/client/sdk/organizations.spec.ts

@@ -0,0 +1,2468 @@
+import { test } from '@pawel-up/lupa/testing'
+import { SdkNetworkMock } from '../../../src/sdk/SdkNetworkMock.js'
+import { StoreSdk } from '../../../src/sdk/StoreSdkWeb.js'
+import { RouteBuilder } from '../../../src/sdk/RouteBuilder.js'
+import type { PatchInfo } from '../../../src/patch/types.js'
+import type { InvitationSchema } from '../../../src/models/store/Invitation.js'
+import { InvitationKind, OrganizationKind, UserKind } from '../../../src/models/kinds.js'
+import type { OrganizationSchema, UserOrganizationGrantType } from '../../../src/models/store/Organization.js'
+import type { UserSchema } from '../../../src/models/store/User.js'
+import type { ContextListOptions, ContextListResult } from '../../../src/events/BaseEvents.js'
+import { Exception } from '../../../src/exceptions/exception.js'
+
+const baseUri = globalThis.location.protocol + '//' + globalThis.location.host
+const baseToken = 'test-token'
+
+test.group('list()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+
+  const mockOrganizations: OrganizationSchema[] = [
+    {
+      kind: OrganizationKind,
+      key: 'org-abc-123',
+      name: 'Organization Alpha',
+      slug: 'organization-alpha',
+      createdBy: 'user-creator-1',
+      createdDate: Date.now() - 86400000,
+      grantType: 'owner',
+    },
+    {
+      kind: OrganizationKind,
+      key: 'org-def-456',
+      name: 'Organization Beta',
+      slug: 'organization-beta',
+      createdBy: 'user-creator-2',
+      createdDate: Date.now() - 172800000,
+      grantType: 'editor',
+    },
+  ]
+  const mockResponse: ContextListResult<OrganizationSchema> = { data: mockOrganizations }
+
+  test('should successfully list organizations', async ({ network, assert }) => {
+    const handle = await mocker.organizations.list(network, {
+      response: {
+        body: JSON.stringify(mockResponse),
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.list()
+
+    await handle.assert.calledOnce('list organizations was called once')
+    await handle.assert.calledWith({
+      method: 'GET',
+      url: sdk.getUrl(RouteBuilder.organizations()).toString(),
+      headers: {
+        Authorization: `Bearer ${baseToken}`,
+      },
+    })
+
+    assert.deepEqual(result, mockResponse, 'list organizations returned expected result')
+  })
+
+  test('should use custom token if provided in request options', async ({ network, assert }) => {
+    const handle = await mocker.organizations.list(network, {
+      response: {
+        body: JSON.stringify(mockResponse),
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.list({ token: 'custom-org-list-token' })
+
+    await handle.assert.calledOnce('list organizations was called once')
+    await handle.assert.calledWith({
+      method: 'GET',
+      url: sdk.getUrl(RouteBuilder.organizations()).toString(),
+      headers: {
+        Authorization: `Bearer custom-org-list-token`,
+      },
+    })
+
+    assert.deepEqual(result, mockResponse, 'list organizations returned expected result')
+  })
+
+  test('should throw an error if API returns a non-200 status', async ({ network, assert }) => {
+    const errorPayload = {
+      message: 'Server Error For Orgs',
+      status: 500,
+      help: 'Try again.',
+      name: 'OrgListServerError',
+      code: 'E_ORG_LIST_SERVER_ERROR',
+    }
+    await mocker.organizations.list(network, {
+      response: {
+        body: JSON.stringify(errorPayload),
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.list(),
+      Exception,
+      'Server Error For Orgs'
+    )
+    assert.strictEqual(error.status, 500)
+    assert.strictEqual(error.help, 'Try again.')
+    assert.strictEqual(error.name, 'OrgListServerError')
+    assert.strictEqual(error.code, 'E_ORG_LIST_SERVER_ERROR')
+  })
+
+  test('should throw an error if API response has no body', async ({ network, assert }) => {
+    await mocker.organizations.list(network, {
+      response: {
+        status: 200,
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.list(),
+      Exception,
+      'Unable to list your organizations. The response has no value.'
+    )
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/orgs-base'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.list(network, {
+      response: {
+        body: JSON.stringify(mockResponse),
+        status: 200,
+      },
+      baseUri: customBaseUri,
+    })
+    await sdk.organizations.list()
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      url: 'http://localhost:3000/api/orgs-base/v1/orgs',
+      headers: {
+        Authorization: `Bearer ${baseToken}`,
+      },
+    })
+  })
+})
+
+test.group('create()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const newOrgName = 'My New Organization'
+  const newOrgSlug = 'my-new-organization'
+  const mockCreatedOrganization: OrganizationSchema = {
+    kind: OrganizationKind,
+    key: 'org-newly-created-789',
+    slug: newOrgSlug,
+    name: newOrgName,
+    createdBy: 'user-current-creator',
+    createdDate: Date.now(),
+    grantType: 'owner', // Typically, the creator becomes the owner
+  }
+
+  test('should successfully create an organization', async ({ network, assert }) => {
+    const handle = await mocker.organizations.create(network, {
+      response: {
+        status: 200, // As per SDK implementation, expects 200 for create
+        body: JSON.stringify({ data: mockCreatedOrganization }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.create(newOrgName, newOrgSlug)
+
+    await handle.assert.calledOnce()
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      url: sdk.getUrl(RouteBuilder.organizations()).toString(),
+      headers: {
+        'Authorization': `Bearer ${baseToken}`,
+        'Content-Type': 'application/json',
+      },
+    })
+    assert.deepEqual(result, mockCreatedOrganization)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.create(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockCreatedOrganization }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.create(newOrgName, newOrgSlug, { token: 'custom-create-org-token' })
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      url: sdk.getUrl(RouteBuilder.organizations()).toString(),
+      headers: {
+        'Authorization': `Bearer custom-create-org-token`,
+        'Content-Type': 'application/json',
+      },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status (e.g., 500)', async ({ network, assert }) => {
+    const errorPayload = {
+      message: 'Server Error Creating Org',
+      status: 500,
+      help: 'Try again.',
+      name: 'OrgCreateServerError',
+      code: 'E_ORG_CREATE_SERVER_ERROR',
+    }
+    await mocker.organizations.create(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify(errorPayload),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.create(newOrgName, newOrgSlug),
+      Exception,
+      'Server Error Creating Org'
+    )
+    assert.strictEqual(error.status, 500)
+    assert.strictEqual(error.help, 'Try again.')
+    assert.strictEqual(error.name, 'OrgCreateServerError')
+    assert.strictEqual(error.code, 'E_ORG_CREATE_SERVER_ERROR')
+  })
+
+  test('should throw an error if API response has no body on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.create(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.create(newOrgName, newOrgSlug),
+      Exception,
+      'Unable to create an organization. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response data is missing "kind" property on 200 status', async ({
+    network,
+    assert,
+  }) => {
+    const invalidResponse = { ...mockCreatedOrganization }
+    // @ts-expect-error Testing missing kind property
+    delete invalidResponse.kind
+    await mocker.organizations.create(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.create(newOrgName, newOrgSlug),
+      Exception,
+      'Unable to create an organization. Unknown response from the server.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+})
+
+test.group('slugs.generate()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const orgName = 'Test Organization Name'
+  const mockSlugResponse = { slug: 'test-organization-name' }
+
+  test('should successfully generate a slug for an organization name', async ({ network, assert }) => {
+    const handle = await mocker.organizations.slugs.generate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockSlugResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.slugs.generate(orgName)
+
+    const expectedUrl = sdk.getUrl(RouteBuilder.orgSlugGenerate()).toString()
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      url: expectedUrl,
+      headers: {
+        'Authorization': `Bearer ${baseToken}`,
+        'Content-Type': 'application/json',
+      },
+    })
+    assert.strictEqual(result, mockSlugResponse.slug)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.slugs.generate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockSlugResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.slugs.generate(orgName, { token: 'custom-slug-token' })
+    await handle.assert.calledOnceWith({
+      headers: { Authorization: `Bearer custom-slug-token` },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status', async ({ network, assert }) => {
+    const errorPayload = {
+      message: 'Server Error Generating Slug',
+      status: 500,
+    }
+    await mocker.organizations.slugs.generate(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify(errorPayload),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.slugs.generate(orgName),
+      Exception,
+      errorPayload.message
+    )
+    assert.strictEqual(error.status, 500)
+  })
+
+  test('should throw an error if API response has no body', async ({ network, assert }) => {
+    await mocker.organizations.slugs.generate(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.slugs.generate(orgName),
+      Exception,
+      'Unable to generate the slug. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response body is invalid JSON', async ({ network, assert }) => {
+    await mocker.organizations.slugs.generate(network, {
+      response: {
+        status: 200,
+        body: 'not json',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.slugs.generate(orgName),
+      Exception,
+      'Unable to generate the slug. Invalid JSON response.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response data is missing "slug" property', async ({ network, assert }) => {
+    const invalidResponse = { other: 'stuff' }
+    await mocker.organizations.slugs.generate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.slugs.generate(orgName),
+      Exception,
+      'Unable to generate the slug. Unknown response from the server.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+})
+
+test.group('slugs.validate()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const orgSlug = 'test-organization-name'
+  const mockValidateResponse = { valid: true }
+
+  test('should successfully validate an organization slug', async ({ network, assert }) => {
+    const handle = await mocker.organizations.slugs.validate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockValidateResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.slugs.validate(orgSlug)
+
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      headers: { Authorization: `Bearer ${baseToken}` },
+      body: JSON.stringify({ slug: orgSlug }),
+    })
+    assert.deepEqual(result, mockValidateResponse)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.slugs.validate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockValidateResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.slugs.validate(orgSlug, { token: 'custom-validate-token' })
+    await handle.assert.calledOnceWith({
+      headers: { Authorization: `Bearer custom-validate-token` },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status', async ({ network, assert }) => {
+    const errorPayload = {
+      message: 'Server Error Validating Slug',
+      status: 500,
+    }
+    await mocker.organizations.slugs.validate(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify(errorPayload),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.slugs.validate(orgSlug),
+      Exception,
+      errorPayload.message
+    )
+    assert.strictEqual(error.status, 500)
+  })
+
+  test('should throw an error if API response has no body', async ({ network, assert }) => {
+    await mocker.organizations.slugs.validate(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.slugs.validate(orgSlug),
+      Exception,
+      'Unable to validate the slug. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response body is invalid JSON', async ({ network, assert }) => {
+    await mocker.organizations.slugs.validate(network, {
+      response: {
+        status: 200,
+        body: 'not json',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.slugs.validate(orgSlug),
+      Exception,
+      'Unable to validate the slug. Invalid JSON response.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response data is missing "valid" property', async ({ network, assert }) => {
+    const invalidResponse = { other: 'stuff' }
+    await mocker.organizations.slugs.validate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.slugs.validate(orgSlug),
+      Exception,
+      'Unable to validate the slug. Unknown response from the server.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+})
+
+test.group('invitations.list()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-list-inv-456'
+  const mockInvitationList: InvitationSchema[] = [
+    {
+      kind: InvitationKind,
+      key: 'inv-abc-123',
+      email: 'test1@example.com',
+      name: 'Test User 1',
+      grantType: 'editor',
+      oid,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      expiresAt: new Date(Date.now() + 86400000).getTime(),
+      status: 'pending',
+      token: 'token1',
+      uid: 'user1',
+      resent: 0,
+      lastSentAt: 0,
+    },
+    {
+      kind: InvitationKind,
+      key: 'inv-def-456',
+      email: 'test2@example.com',
+      name: 'Test User 2',
+      grantType: 'viewer',
+      oid,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      expiresAt: new Date(Date.now() + 172800000).getTime(),
+      status: 'accepted',
+      token: 'token2',
+      uid: 'user2',
+      resent: 0,
+      lastSentAt: 0,
+    },
+  ]
+  const mockResponse = { data: mockInvitationList }
+
+  test('should successfully list invitations', async ({ network, assert }) => {
+    const handle = await mocker.organizations.invitations.list(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.invitations.list(oid)
+
+    await handle.assert.calledOnceWith({
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+    assert.deepEqual(result, mockResponse)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.invitations.list(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.invitations.list(oid, { token: 'custom-list-token' })
+    await handle.assert.calledOnceWith({
+      headers: { Authorization: `Bearer custom-list-token` },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.list(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify({
+          message: 'Internal Server Error',
+          status: 500,
+          help: 'Please try again later.',
+          name: 'InternalServerError',
+          code: 'E_INTERNAL_SERVER_ERROR',
+        }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.list(oid),
+      Exception,
+      'Internal Server Error'
+    )
+    assert.strictEqual(error.help, 'Please try again later.')
+    assert.strictEqual(error.name, 'InternalServerError')
+    assert.strictEqual(error.code, 'E_INTERNAL_SERVER_ERROR')
+    assert.strictEqual(error.status, 500)
+  })
+
+  test('should throw an error if API response has no body', async ({ network, assert }) => {
+    await mocker.organizations.invitations.list(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.list(oid),
+      Exception,
+      'Unable to list organization invitations. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response body is invalid JSON', async ({ network, assert }) => {
+    await mocker.organizations.invitations.list(network, {
+      response: {
+        status: 200,
+        body: 'this is not json',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.list(oid),
+      Exception,
+      'Unable to list organization invitations. Invalid JSON response.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response data is missing "data" array', async ({ network, assert }) => {
+    await mocker.organizations.invitations.list(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: { kind: OrganizationKind, otherData: 'stuff' } }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.list(oid),
+      Exception,
+      'Unable to list organization invitations. Unknown response from the server.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+})
+
+test.group('invitations.create()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-test-123'
+  const email = 'invitee@example.com'
+  const grantType: UserOrganizationGrantType = 'viewer'
+  const name = 'Invitee Name'
+  const mockInvitation: InvitationSchema = {
+    kind: InvitationKind,
+    key: 'inv-new-789',
+    email,
+    name,
+    grantType,
+    oid,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    expiresAt: new Date(Date.now() + 86400000).getTime(), // tomorrow
+    status: 'pending',
+    token: 'new-invitation-token',
+    uid: 'user-new-abc',
+    resent: 0,
+    lastSentAt: 0,
+  }
+
+  test('should successfully create an invitation with name', async ({ network, assert }) => {
+    const handle = await mocker.organizations.invitations.create(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.invitations.create(oid, email, grantType, name, {
+      token: 'custom-invite-token',
+    })
+
+    await handle.assert.calledOnceWith({
+      headers: { 'Authorization': `Bearer custom-invite-token`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, name, grant_type: grantType }),
+    })
+    assert.deepEqual(result, mockInvitation)
+  })
+
+  test('should successfully create an invitation without name', async ({ network, assert }) => {
+    const mockInvitationWithoutName = { ...mockInvitation }
+    delete mockInvitationWithoutName.name // Simulate no name provided
+    const handle = await mocker.organizations.invitations.create(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockInvitationWithoutName }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.invitations.create(oid, email, grantType, undefined, {
+      token: 'custom-invite-token',
+    })
+
+    await handle.assert.calledOnceWith({
+      headers: { 'Authorization': `Bearer custom-invite-token`, 'Content-Type': 'application/json' },
+      body: JSON.stringify({ email, grant_type: grantType }),
+    })
+    assert.deepEqual(result, mockInvitationWithoutName)
+  })
+
+  test('should use default token if none provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.invitations.create(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.invitations.create(oid, email, grantType, name)
+    await handle.assert.calledOnceWith({
+      headers: { 'Authorization': `Bearer ${baseToken}`, 'Content-Type': 'application/json' },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.create(network, {
+      response: {
+        body: JSON.stringify({
+          message: 'Server Error',
+          status: 500,
+          help: 'Please try again later.',
+          name: 'InternalServerError',
+          code: 'E_INTERNAL_SERVER_ERROR',
+        }),
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.create(oid, email, grantType, name),
+      Exception,
+      'Server Error'
+    )
+    assert.strictEqual(error.status, 500)
+    assert.strictEqual(error.help, 'Please try again later.')
+    assert.strictEqual(error.name, 'InternalServerError')
+    assert.strictEqual(error.code, 'E_INTERNAL_SERVER_ERROR')
+  })
+
+  test('should throw an error if API response has no body', async ({ network, assert }) => {
+    await mocker.organizations.invitations.create(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.create(oid, email, grantType, name),
+      Exception,
+      'Unable to create an invitation. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response body is invalid JSON', async ({ network, assert }) => {
+    await mocker.organizations.invitations.create(network, {
+      response: {
+        status: 200,
+        body: 'not json',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.create(oid, email, grantType, name),
+      Exception,
+      'Unable to create an invitation. Invalid JSON response.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response data is missing "kind" property', async ({ network, assert }) => {
+    const invalidResponse = { ...mockInvitation }
+    // @ts-expect-error Testing missing kind property
+    delete invalidResponse.kind
+    await mocker.organizations.invitations.create(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.create(oid, email, grantType, name),
+      Exception,
+      'Unable to create an invitation. Unknown response from the server.'
+    )
+  })
+})
+
+test.group('invitations.patch()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-123'
+  const id = 'inv-456'
+  const patchInfo: PatchInfo = {
+    id: 'inv-456',
+    patch: [{ op: 'replace', path: '/name', value: 'New Name' }],
+    timestamp: Date.now(),
+  }
+  const mockInvitation: InvitationSchema = {
+    kind: InvitationKind,
+    key: 'inv-456',
+    email: 'test@example.com',
+    name: 'New Name',
+    grantType: 'editor',
+    oid: 'org-123',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    expiresAt: new Date(Date.now() + 86400000).getTime(), // tomorrow
+    status: 'pending',
+    token: 'invitation-token',
+    uid: 'user-789',
+    resent: 0,
+    lastSentAt: 0,
+  }
+
+  test('should successfully patch an invitation', async ({ network, assert }) => {
+    const handle = await mocker.organizations.invitations.patch(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.invitations.patch(oid, id, patchInfo, { token: 'custom-token' })
+
+    await handle.assert.calledOnceWith({
+      headers: { 'Authorization': `Bearer custom-token`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(patchInfo),
+    })
+    assert.deepEqual(result, mockInvitation)
+  })
+
+  test('should use default token if none provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.invitations.patch(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.invitations.patch(oid, id, patchInfo)
+    await handle.assert.calledOnceWith({
+      headers: { 'Authorization': `Bearer ${baseToken}`, 'Content-Type': 'application/json' },
+      body: JSON.stringify(patchInfo),
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.patch(network, {
+      response: {
+        status: 400,
+        body: JSON.stringify({
+          message: 'Bad Request',
+          status: 400,
+          help: 'Please try again later.',
+          name: 'InternalServerError',
+          code: 'E_INTERNAL_SERVER_ERROR',
+        }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.patch(oid, id, patchInfo),
+      Exception,
+      'Bad Request'
+    )
+
+    assert.strictEqual(error.help, 'Please try again later.')
+    assert.strictEqual(error.name, 'InternalServerError')
+    assert.strictEqual(error.code, 'E_INTERNAL_SERVER_ERROR')
+    assert.strictEqual(error.status, 400)
+  })
+
+  test('should throw an error if API response has no body', async ({ network, assert }) => {
+    await mocker.organizations.invitations.patch(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.patch(oid, id, patchInfo),
+      Exception,
+      'Unable to update invitation. The response has no value.'
+    )
+  })
+
+  test('should throw an error if API response body is invalid JSON', async ({ network, assert }) => {
+    await mocker.organizations.invitations.patch(network, {
+      response: {
+        status: 200,
+        body: 'invalid json',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.patch(oid, id, patchInfo),
+      Exception,
+      'Unable to update invitation. Invalid JSON response.'
+    )
+  })
+
+  test('should throw an error if API response data is missing "kind" property', async ({ network, assert }) => {
+    const invalidInvitation = { ...mockInvitation }
+    // @ts-expect-error Testing missing kind property
+    delete invalidInvitation.kind
+    await mocker.organizations.invitations.patch(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.patch(oid, id, patchInfo),
+      Exception,
+      'Unable to update invitation. Unknown response from the server.'
+    )
+  })
+})
+
+test.group('invitations.findByToken()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-find-inv-by-token-001'
+  const targetInvitationToken = 'a-valid-invitation-token-for-finding'
+  const mockFoundInvitation: InvitationSchema = {
+    kind: InvitationKind,
+    key: 'inv-found-xyz-789',
+    email: 'found@example.com',
+    name: 'Found User',
+    grantType: 'owner',
+    oid,
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    expiresAt: new Date(Date.now() + 86400000 * 2).getTime(), // 2 days
+    status: 'pending',
+    token: targetInvitationToken,
+    uid: 'user-found-abc',
+    resent: 0,
+    lastSentAt: 0,
+  }
+
+  test('should successfully find an invitation by token', async ({ network, assert }) => {
+    const handle = await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockFoundInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.invitations.findByToken(targetInvitationToken)
+
+    const expectedBaseUrl = sdk.getUrl(RouteBuilder.findInvitation())
+    const expectedUrlWithToken = new URL(expectedBaseUrl.toString())
+    expectedUrlWithToken.searchParams.set('token', targetInvitationToken)
+
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+    assert.deepEqual(result, mockFoundInvitation)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockFoundInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.invitations.findByToken(targetInvitationToken, { token: 'custom-find-token' })
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      headers: { Authorization: `Bearer custom-find-token` },
+    })
+  })
+
+  test('should throw an Exception if API returns a non-200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify({
+          message: 'Server Error',
+          status: 500,
+          help: 'Please try again later.',
+          name: 'InternalServerError',
+          code: 'E_INTERNAL_SERVER_ERROR',
+        }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.findByToken(targetInvitationToken),
+      Exception,
+      'Server Error'
+    )
+    assert.strictEqual(error.help, 'Please try again later.')
+    assert.strictEqual(error.name, 'InternalServerError')
+    assert.strictEqual(error.code, 'E_INTERNAL_SERVER_ERROR')
+    assert.strictEqual(error.status, 500)
+  })
+
+  test('should throw an Exception if API returns 404 (handled by inspectCommonStatusCodes)', async ({
+    network,
+    assert,
+  }) => {
+    // Note: inspectCommonStatusCodes will use a generic "Not found." message
+    // if the response body isn't a valid Exception.
+    await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 404,
+        body: JSON.stringify({ msg: 'Resource does not exist' }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.findByToken(targetInvitationToken),
+      Exception,
+      'Not found'
+    )
+    assert.strictEqual(error.status, 404)
+  })
+
+  test('should throw an Exception if API response has no body on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.findByToken(targetInvitationToken),
+      Exception,
+      'Unable to find invitation by token. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an Exception if API response body is invalid JSON on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 200,
+        body: 'this is not json at all',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.findByToken(targetInvitationToken),
+      Exception,
+      'Unable to find invitation by token. Invalid JSON response.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an Exception if API response data is missing "kind" property on 200 status', async ({
+    network,
+    assert,
+  }) => {
+    const invalidResponse = { ...mockFoundInvitation }
+    // @ts-expect-error Testing missing kind property
+    delete invalidResponse.kind
+    await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.findByToken(targetInvitationToken),
+      Exception,
+      'Unable to find invitation by token. Unknown response from the server.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an Exception if API response data is missing "kind" property on 200 status', async ({
+    network,
+    assert,
+  }) => {
+    const invalidResponse = { ...mockFoundInvitation }
+    // @ts-expect-error Testing missing kind property
+    delete invalidResponse.kind
+    await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.findByToken(targetInvitationToken),
+      Exception,
+      'Unable to find invitation by token. Unknown response from the server.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/v2'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.invitations.findByToken(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockFoundInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+      baseUri: customBaseUri,
+    })
+
+    await sdk.organizations.invitations.findByToken(targetInvitationToken)
+
+    const expectedBaseUrl = sdk.getUrl(RouteBuilder.findInvitation()) // Should be http://localhost:3000/api/v2/v1/orgs/...
+    const expectedUrlWithToken = new URL(expectedBaseUrl.toString())
+    expectedUrlWithToken.searchParams.set('token', targetInvitationToken)
+
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      url: expectedUrlWithToken.toString(),
+    })
+  })
+})
+
+test.group('invitations.decline()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-decline-inv-test-001'
+  const invitationId = 'inv-to-decline-456'
+  const mockDeclinedInvitation: InvitationSchema = {
+    kind: InvitationKind,
+    key: invitationId,
+    email: 'declined@example.com',
+    name: 'Declined User',
+    grantType: 'viewer',
+    oid,
+    createdAt: Date.now() - 100000, // Some time ago
+    updatedAt: Date.now(), // Updated now
+    expiresAt: new Date(Date.now() + 86400000).getTime(), // Expires tomorrow
+    status: 'declined',
+    token: 'old-invitation-token-now-declined',
+    uid: 'user-who-declined',
+    resent: 0,
+    lastSentAt: 0,
+  }
+
+  test('should successfully decline an invitation', async ({ network, assert }) => {
+    const handle = await mocker.organizations.invitations.decline(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockDeclinedInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.invitations.decline(oid, invitationId)
+
+    const expectedUrl = sdk.getUrl(RouteBuilder.declineInvitation(oid, invitationId)).toString()
+
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      url: expectedUrl,
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+    assert.deepEqual(result, mockDeclinedInvitation)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.invitations.decline(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockDeclinedInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await sdk.organizations.invitations.decline(oid, invitationId, { token: 'custom-decline-token' })
+
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      headers: { Authorization: `Bearer custom-decline-token` },
+    })
+  })
+
+  test('should throw an Exception if API returns a non-200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.decline(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify({
+          message: 'Server Error',
+          status: 500,
+          help: 'Please try again later.',
+          name: 'InternalServerError',
+          code: 'E_INTERNAL_SERVER_ERROR',
+        }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.decline(oid, invitationId),
+      Exception,
+      'Server Error'
+    )
+    assert.strictEqual(error.help, 'Please try again later.')
+    assert.strictEqual(error.name, 'InternalServerError')
+    assert.strictEqual(error.code, 'E_INTERNAL_SERVER_ERROR')
+    assert.strictEqual(error.status, 500)
+  })
+
+  test('should throw an Exception if API returns 404 (handled by inspectCommonStatusCodes)', async ({
+    network,
+    assert,
+  }) => {
+    await mocker.organizations.invitations.decline(network, {
+      response: {
+        status: 404,
+        body: JSON.stringify({ msg: 'Invitation not found to decline' }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.decline(oid, invitationId),
+      Exception,
+      'Not found'
+    )
+    assert.strictEqual(error.status, 404)
+  })
+
+  test('should throw an Exception if API response has no body on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.decline(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.decline(oid, invitationId),
+      Exception,
+      'Unable to decline invitation. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an Exception if API response body is invalid JSON on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.decline(network, {
+      response: {
+        status: 200,
+        body: 'not a valid json response for decline',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.decline(oid, invitationId),
+      Exception,
+      'Unable to decline invitation. Invalid JSON response.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an Exception if API response data is missing "kind" property on 200 status', async ({
+    network,
+    assert,
+  }) => {
+    const invalidResponse = { ...mockDeclinedInvitation }
+    // @ts-expect-error Testing missing kind property
+    delete invalidResponse.kind
+
+    await mocker.organizations.invitations.decline(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.decline(oid, invitationId),
+      Exception,
+      'Unable to decline invitation. Unknown response from the server.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/v3'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.invitations.decline(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockDeclinedInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+      baseUri: customBaseUri,
+    })
+
+    await sdk.organizations.invitations.decline(oid, invitationId)
+    const expectedUrl = sdk.getUrl(RouteBuilder.declineInvitation(oid, invitationId)).toString()
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      url: expectedUrl,
+    })
+  })
+})
+
+test.group('invitations.delete()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-delete-inv-op-002'
+  const invitationIdToDelete = 'inv-to-be-deleted-789'
+  const mockSoftDeletedInvitation: InvitationSchema = {
+    kind: InvitationKind,
+    key: invitationIdToDelete,
+    email: 'deleted@example.com',
+    name: 'Deleted User',
+    grantType: 'owner',
+    oid,
+    createdAt: Date.now() - 200000, // Some time ago
+    updatedAt: Date.now(), // Updated now
+    deleted: true, // Soft-deleted flag
+    deletedInfo: {
+      byMe: true, // Indicating the user who deleted it
+      time: Date.now(),
+    },
+    expiresAt: new Date(Date.now() + 86400000 * 3).getTime(), // Expires in 3 days
+    status: 'declined',
+    token: 'old-invitation-token-now-deleted-xyz',
+    uid: 'user-who-was-deleted',
+    resent: 0,
+    lastSentAt: 0,
+  }
+
+  test('should successfully soft-delete an invitation and return it', async ({ network, assert }) => {
+    const handle = await mocker.organizations.invitations.delete(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockSoftDeletedInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.invitations.delete(oid, invitationIdToDelete)
+
+    const expectedUrl = sdk.getUrl(RouteBuilder.invitation(oid, invitationIdToDelete)).toString()
+    await handle.assert.calledOnceWith({
+      method: 'DELETE',
+      url: expectedUrl,
+    })
+    assert.deepEqual(result, mockSoftDeletedInvitation)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.invitations.delete(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockSoftDeletedInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.invitations.delete(oid, invitationIdToDelete, { token: 'custom-delete-op-token' })
+    await handle.assert.calledOnceWith({
+      method: 'DELETE',
+      headers: { Authorization: 'Bearer custom-delete-op-token' },
+    })
+  })
+
+  test('should throw an Exception if API returns a non-200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.delete(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify({
+          message: 'Server Error',
+          status: 500,
+          help: 'Please try again later.',
+          name: 'InternalServerError',
+          code: 'E_INTERNAL_SERVER_ERROR',
+        }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.delete(oid, invitationIdToDelete),
+      Exception,
+      'Server Error'
+    )
+    assert.strictEqual(error.help, 'Please try again later.')
+    assert.strictEqual(error.name, 'InternalServerError')
+    assert.strictEqual(error.code, 'E_INTERNAL_SERVER_ERROR')
+  })
+
+  test('should throw an Exception if API returns 404 (handled by inspectCommonStatusCodes)', async ({
+    network,
+    assert,
+  }) => {
+    await mocker.organizations.invitations.delete(network, {
+      response: {
+        status: 404,
+        body: JSON.stringify({ msg: 'Invitation not found to delete' }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.delete(oid, invitationIdToDelete),
+      Exception,
+      'Not found'
+    )
+    assert.strictEqual(error.status, 404)
+  })
+
+  test('should throw an Exception if API response has no body on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.delete(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.delete(oid, invitationIdToDelete),
+      Exception,
+      'Unable to delete invitation. The response has no value.'
+    )
+  })
+
+  test('should throw an Exception if API response body is invalid JSON on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.invitations.delete(network, {
+      response: {
+        status: 200,
+        body: 'this is not json for delete op',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.delete(oid, invitationIdToDelete),
+      Exception,
+      'Unable to delete invitation. Invalid JSON response.'
+    )
+  })
+
+  test('should throw an Exception if API response data is missing "kind" property on 200 status', async ({
+    network,
+    assert,
+  }) => {
+    const invalidResponse = { ...mockSoftDeletedInvitation }
+    // @ts-expect-error Testing missing kind property
+    delete invalidResponse.kind
+
+    await mocker.organizations.invitations.delete(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: invalidResponse }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.invitations.delete(oid, invitationIdToDelete),
+      Exception,
+      'Unable to delete invitation. Unknown response from the server.'
+    )
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/v4'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.invitations.delete(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockSoftDeletedInvitation }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+      baseUri: customBaseUri,
+    })
+    await sdk.organizations.invitations.delete(oid, invitationIdToDelete)
+    const expectedUrl = sdk.getUrl(RouteBuilder.invitation(oid, invitationIdToDelete)).toString()
+    await handle.assert.calledOnceWith({
+      method: 'DELETE',
+      url: expectedUrl,
+    })
+  })
+})
+
+test.group('users.list()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-user-list-789'
+  const mockUserList: UserSchema[] = [
+    {
+      key: 'user-abc-123',
+      kind: UserKind,
+      name: 'User Alpha',
+      email: [{ email: 'alpha@example.com' }],
+      created: 1,
+      updated: 2,
+    },
+    {
+      key: 'user-def-456',
+      kind: UserKind,
+      name: 'User Beta',
+      email: [{ email: 'beta@example.com' }],
+      created: 3,
+      updated: 4,
+    },
+  ]
+  const mockResponse: ContextListResult<UserSchema> = { data: mockUserList }
+
+  test('should successfully list users in an organization', async ({ network, assert }) => {
+    const handle = await mocker.organizations.users.list(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.users.list(oid)
+
+    const expectedUrl = sdk.getUrl(RouteBuilder.organizationUsers(oid)).toString()
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      url: expectedUrl,
+    })
+    assert.deepEqual(result, mockResponse)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.users.list(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.users.list(oid, undefined, { token: 'custom-user-list-token' })
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      headers: { Authorization: 'Bearer custom-user-list-token' },
+    })
+  })
+
+  test('should append ContextListOptions to the URL', async ({ network }) => {
+    const handle = await mocker.organizations.users.list(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const listOptions: ContextListOptions = { limit: 10, cursor: 'next-page', sort: 'name', order: 'asc' }
+    await sdk.organizations.users.list(oid, listOptions)
+
+    const expectedUrl = sdk.getUrl(RouteBuilder.organizationUsers(oid))
+    sdk.appendListOptions(expectedUrl, listOptions) // Helper to build expected URL with options
+
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      url: expectedUrl.toString(),
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.list(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify({
+          message: 'Server Error For Users',
+          status: 500,
+          help: 'Try again.',
+          name: 'UserListServerError',
+          code: 'E_USER_LIST_SERVER_ERROR',
+        }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.list(oid),
+      Exception,
+      'Server Error For Users'
+    )
+
+    assert.strictEqual(error.help, 'Try again.')
+    assert.strictEqual(error.name, 'UserListServerError')
+    assert.strictEqual(error.code, 'E_USER_LIST_SERVER_ERROR')
+    assert.strictEqual(error.status, 500)
+  })
+
+  test('should throw an error if API response has no body', async ({ network, assert }) => {
+    await mocker.organizations.users.list(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.list(oid),
+      Exception,
+      'Unable to list projects. The response has no value.'
+    )
+  })
+
+  test('should throw an error if API response body is invalid JSON', async ({ network, assert }) => {
+    await mocker.organizations.users.list(network, {
+      response: {
+        status: 200,
+        body: 'this is not json for users',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.list(oid),
+      Exception,
+      'Unable to list projects. Invalid JSON response.'
+    )
+  })
+
+  test('should throw an error if API response data is missing "data" array', async ({ network, assert }) => {
+    await mocker.organizations.users.list(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ kind: 'list', otherData: 'no data here' }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.list(oid),
+      Exception,
+      'Unable to list projects. Unknown response from the server.'
+    )
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/v5'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.users.list(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+      baseUri: customBaseUri,
+    })
+    await sdk.organizations.users.list(oid)
+    const expectedUrl = sdk.getUrl(RouteBuilder.organizationUsers(oid)).toString()
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      url: expectedUrl,
+    })
+  })
+})
+
+test.group('users.read()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-user-read-123'
+  const userId = 'user-to-read-456'
+  const mockUser: UserSchema = {
+    key: userId,
+    kind: UserKind,
+    name: 'Specific User',
+    email: [{ email: 'specific@example.com', verified: true }],
+    created: Date.now() - 100000,
+    updated: Date.now(),
+    status: 'active',
+  }
+
+  test('should successfully read a user from an organization', async ({ network, assert }) => {
+    const handle = await mocker.organizations.users.read(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockUser }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.users.read(oid, userId)
+
+    const expectedUrl = sdk.getUrl(RouteBuilder.organizationUser(oid, userId)).toString()
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      url: expectedUrl,
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+    assert.deepEqual(result, mockUser)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.users.read(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockUser }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.users.read(oid, userId, { token: 'custom-read-user-token' })
+    await handle.assert.calledOnceWith({
+      method: 'GET',
+      headers: { Authorization: `Bearer custom-read-user-token` },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status (e.g., 500)', async ({ network, assert }) => {
+    const errorResponse = {
+      message: 'Server Error For Reading User',
+      status: 500,
+      help: 'Try again later.',
+      name: 'UserReadServerError',
+      code: 'E_USER_READ_SERVER_ERROR',
+    }
+    await mocker.organizations.users.read(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify(errorResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.read(oid, userId),
+      Exception,
+      errorResponse.message
+    )
+    assert.strictEqual(error.help, errorResponse.help)
+    assert.strictEqual(error.name, errorResponse.name)
+    assert.strictEqual(error.code, errorResponse.code)
+    assert.strictEqual(error.status, errorResponse.status)
+  })
+
+  test('should throw an error if API returns 404 (Not Found)', async ({ network, assert }) => {
+    await mocker.organizations.users.read(network, {
+      response: {
+        status: 404,
+        body: JSON.stringify({ message: 'User not found' }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.read(oid, userId),
+      Exception,
+      'User not found'
+    )
+    assert.strictEqual(error.status, 404)
+  })
+
+  test('should throw an error if API response has no body on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.read(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.read(oid, userId),
+      Exception,
+      'Unable to read the user info. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response body is invalid JSON on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.read(network, {
+      response: {
+        status: 200,
+        body: 'this is not json for a single user',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.read(oid, userId),
+      Exception,
+      'Unable to read the user info. Invalid JSON response.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/v6'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.users.read(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockUser }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+      baseUri: customBaseUri,
+    })
+    await sdk.organizations.users.read(oid, userId)
+    await handle.assert.calledOnceWith({
+      url: `http://localhost:3000/api/v6/v1/orgs/${oid}/users/${userId}`,
+    })
+  })
+})
+
+test.group('users.activate()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-user-activate-789'
+  const userId = 'user-to-activate-101'
+  const mockActivatedUser: UserSchema = {
+    key: userId,
+    kind: UserKind,
+    name: 'Newly Activated User',
+    email: [{ email: 'activated@example.com', verified: true }],
+    created: Date.now() - 200000,
+    updated: Date.now(),
+    status: 'active', // Key change
+  }
+
+  test('should successfully activate a user in an organization', async ({ network, assert }) => {
+    const handle = await mocker.organizations.users.activate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockActivatedUser }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.users.activate(oid, userId)
+
+    const expectedUrl = sdk.getUrl(RouteBuilder.organizationUserActivate(oid, userId)).toString()
+    await handle.assert.calledOnceWith({
+      url: expectedUrl,
+      method: 'POST',
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+    assert.deepEqual(result, mockActivatedUser)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.users.activate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockActivatedUser),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.users.activate(oid, userId, { token: 'custom-activate-user-token' })
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      headers: { Authorization: `Bearer custom-activate-user-token` },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status (e.g., 500)', async ({ network, assert }) => {
+    const errorResponse = {
+      message: 'Server Error Activating User',
+      status: 500,
+      help: 'Try again later.',
+      name: 'UserActivateServerError',
+      code: 'E_USER_ACTIVATE_SERVER_ERROR',
+    }
+    await mocker.organizations.users.activate(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify(errorResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects(
+      async () => await sdk.organizations.users.activate(oid, userId),
+      Exception,
+      'Server Error Activating User'
+    )
+    assert.strictEqual(error.message, errorResponse.message)
+    assert.strictEqual(error.help, errorResponse.help)
+    assert.strictEqual(error.name, errorResponse.name)
+    assert.strictEqual(error.code, errorResponse.code)
+    assert.strictEqual(error.status, errorResponse.status)
+  })
+
+  test('should throw an error if API returns 400 (e.g., user already active)', async ({ network, assert }) => {
+    const errorResponse = { message: 'User is already active', status: 400, code: 'E_USER_ALREADY_ACTIVE' }
+    await mocker.organizations.users.activate(network, {
+      response: {
+        status: 400,
+        body: JSON.stringify(errorResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects(async () => await sdk.organizations.users.activate(oid, userId), Exception)
+    assert.strictEqual(error.message, errorResponse.message)
+    assert.strictEqual(error.status, 400)
+    assert.strictEqual(error.code, errorResponse.code)
+  })
+
+  test('should throw an error if API response has no body on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.activate(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects(
+      async () => await sdk.organizations.users.activate(oid, userId),
+      Exception,
+      'Unable to activate the user. The response has no value.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should throw an error if API response body is invalid JSON on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.activate(network, {
+      response: {
+        status: 200,
+        body: 'this is not json for activating a user',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects(
+      async () => await sdk.organizations.users.activate(oid, userId),
+      Exception,
+      'Unable to activate the user. Invalid JSON response.'
+    )
+    assert.strictEqual(error.status, 200)
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/v7'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.users.activate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockActivatedUser),
+        headers: { 'Content-Type': 'application/json' },
+      },
+      baseUri: customBaseUri,
+    })
+    await sdk.organizations.users.activate(oid, userId)
+    await handle.assert.calledOnceWith({
+      url: `http://localhost:3000/api/v7/v1/orgs/${oid}/users/${userId}/activate`,
+    })
+  })
+})
+
+test.group('users.deactivate()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-user-deactivate-456'
+  const userId = 'user-to-deactivate-789'
+  const mockDeactivatedUser: UserSchema = {
+    key: userId,
+    kind: UserKind,
+    name: 'Deactivated User',
+    email: [{ email: 'deactivated@example.com', verified: true }],
+    created: Date.now() - 300000,
+    updated: Date.now(),
+    status: 'suspended', // Key change to indicate deactivation
+  }
+
+  test('should successfully deactivate a user in an organization', async ({ network, assert }) => {
+    const handle = await mocker.organizations.users.deactivate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ data: mockDeactivatedUser }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.users.deactivate(oid, userId)
+
+    const expectedUrl = sdk.getUrl(RouteBuilder.organizationUserDeactivate(oid, userId)).toString()
+    await handle.assert.calledOnceWith({
+      url: expectedUrl,
+      method: 'POST',
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+    assert.deepEqual(result, mockDeactivatedUser)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.users.deactivate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockDeactivatedUser),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.users.deactivate(oid, userId, { token: 'custom-deactivate-user-token' })
+    await handle.assert.calledOnceWith({
+      headers: { Authorization: `Bearer custom-deactivate-user-token` },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status (e.g., 500)', async ({ network, assert }) => {
+    const errorResponse = {
+      message: 'Server Error Deactivating User',
+      status: 500,
+      help: 'Try again later.',
+      name: 'UserDeactivateServerError',
+      code: 'E_USER_DEACTIVATE_SERVER_ERROR',
+    }
+    await mocker.organizations.users.deactivate(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify(errorResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects(async () => await sdk.organizations.users.deactivate(oid, userId), Exception)
+    assert.strictEqual(error.message, errorResponse.message)
+    assert.strictEqual(error.help, errorResponse.help)
+    assert.strictEqual(error.name, errorResponse.name)
+    assert.strictEqual(error.code, errorResponse.code)
+    assert.strictEqual(error.status, errorResponse.status)
+  })
+
+  test('should throw an error if API returns 400 (e.g., user already deactivated)', async ({ network, assert }) => {
+    const errorResponse = {
+      message: 'User is already deactivated',
+      status: 400,
+      code: 'E_USER_ALREADY_DEACTIVATED',
+    }
+    await mocker.organizations.users.deactivate(network, {
+      response: {
+        status: 400,
+        body: JSON.stringify(errorResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects(async () => await sdk.organizations.users.deactivate(oid, userId), Exception)
+    assert.strictEqual(error.message, errorResponse.message)
+    assert.strictEqual(error.status, 400)
+    assert.strictEqual(error.code, errorResponse.code)
+  })
+
+  test('should throw an error if API response has no body on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.deactivate(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects(async () => await sdk.organizations.users.deactivate(oid, userId), Exception)
+    assert.strictEqual(error.message, 'Unable to deactivate the user. The response has no value.')
+  })
+
+  test('should throw an error if API response body is invalid JSON on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.deactivate(network, {
+      response: {
+        status: 200,
+        body: 'this is not json for deactivating a user',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects(async () => await sdk.organizations.users.deactivate(oid, userId), Exception)
+    assert.strictEqual(error.message, 'Unable to deactivate the user. Invalid JSON response.')
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/custom'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.users.deactivate(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockDeactivatedUser),
+        headers: { 'Content-Type': 'application/json' },
+      },
+      baseUri: customBaseUri,
+    })
+    await sdk.organizations.users.deactivate(oid, userId)
+    await handle.assert.calledOnceWith({
+      url: `http://localhost:3000/custom/v1/orgs/${oid}/users/${userId}/deactivate`,
+    })
+  })
+})
+
+test.group('users.delete()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-user-delete-op-789'
+  const userIdToDelete = 'user-to-be-deleted-101'
+
+  test('should successfully delete a user from an organization', async ({ network }) => {
+    const handle = await mocker.organizations.users.delete(network)
+
+    await sdk.organizations.users.delete(oid, userIdToDelete)
+
+    await handle.assert.calledOnceWith({
+      method: 'DELETE',
+      url: sdk.getUrl(RouteBuilder.organizationUser(oid, userIdToDelete)).toString(),
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.users.delete(network)
+    await sdk.organizations.users.delete(oid, userIdToDelete, { token: 'custom-delete-user-token' })
+    await handle.assert.calledOnceWith({ headers: { Authorization: `Bearer custom-delete-user-token` } })
+  })
+
+  test('should throw an error if API returns a non-204 status (e.g., 500)', async ({ network, assert }) => {
+    const errorResponse = {
+      message: 'Server Error Deleting User',
+      status: 500,
+      help: 'Try again later.',
+      name: 'UserDeleteServerError',
+      code: 'E_USER_DELETE_SERVER_ERROR',
+    }
+    await mocker.organizations.users.delete(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify(errorResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects(async () => await sdk.organizations.users.delete(oid, userIdToDelete), Exception)
+    assert.strictEqual(error.message, errorResponse.message)
+    assert.strictEqual(error.help, errorResponse.help)
+    assert.strictEqual(error.name, errorResponse.name)
+    assert.strictEqual(error.code, errorResponse.code)
+    assert.strictEqual(error.status, errorResponse.status)
+  })
+
+  test('should throw an error if API returns 404 (Not Found)', async ({ network, assert }) => {
+    await mocker.organizations.users.delete(network, {
+      response: {
+        status: 404,
+        body: JSON.stringify({ message: 'User to delete not found' }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects(async () => await sdk.organizations.users.delete(oid, userIdToDelete), Exception)
+    assert.strictEqual(error.message, 'User to delete not found')
+    assert.strictEqual(error.status, 404)
+  })
+
+  test('should throw an error if API returns 403 (Forbidden)', async ({ network, assert }) => {
+    await mocker.organizations.users.delete(network, {
+      response: {
+        status: 403,
+        body: JSON.stringify({ message: 'Permission denied to delete user' }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    const error = await assert.rejects(async () => await sdk.organizations.users.delete(oid, userIdToDelete), Exception)
+    assert.strictEqual(error.message, 'Permission denied to delete user')
+    assert.strictEqual(error.status, 403)
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/delete-org-user'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.users.delete(network, { baseUri: customBaseUri })
+    await sdk.organizations.users.delete(oid, userIdToDelete)
+    await handle.assert.calledOnceWith({
+      url: `${customBaseUri}/v1/orgs/${oid}/users/${userIdToDelete}`,
+    })
+  })
+})
+
+test.group('users.readBatch()', (group) => {
+  let sdk: StoreSdk
+  let mocker: SdkNetworkMock
+
+  group.each.setup(() => {
+    sdk = new StoreSdk(baseUri)
+    sdk.token = baseToken
+    sdk.silent = true
+    mocker = new SdkNetworkMock(baseUri)
+  })
+  const oid = 'org-user-read-batch-789'
+  const userKeysToRead = ['user-key-alpha', 'user-key-beta', 'user-key-gamma']
+  const mockUserAlpha: UserSchema = {
+    key: 'user-key-alpha',
+    kind: UserKind,
+    name: 'User Alpha Batch',
+    email: [{ email: 'alpha.batch@example.com' }],
+    created: Date.now() - 50000,
+    updated: Date.now() - 10000,
+  }
+  const mockUserBeta: UserSchema = {
+    key: 'user-key-beta',
+    kind: UserKind,
+    name: 'User Beta Batch',
+    email: [{ email: 'beta.batch@example.com', verified: true }],
+    created: Date.now() - 60000,
+    updated: Date.now() - 5000,
+    status: 'active',
+  }
+  const mockUsersInBatch: UserSchema[] = [mockUserAlpha, mockUserBeta]
+  const mockSuccessfulResponse: ContextListResult<UserSchema> = { data: mockUsersInBatch }
+
+  test('should successfully read a batch of users from an organization', async ({ network, assert }) => {
+    const handle = await mocker.organizations.users.readBatch(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockSuccessfulResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const result = await sdk.organizations.users.readBatch(oid, userKeysToRead)
+
+    await handle.assert.calledOnceWith({
+      method: 'POST',
+      body: JSON.stringify({ ids: userKeysToRead }),
+      headers: { Authorization: `Bearer ${baseToken}` },
+    })
+    assert.deepEqual(result, mockSuccessfulResponse)
+  })
+
+  test('should use custom token if provided in request options', async ({ network }) => {
+    const handle = await mocker.organizations.users.readBatch(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockSuccessfulResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await sdk.organizations.users.readBatch(oid, userKeysToRead, { token: 'custom-read-batch-token' })
+    await handle.assert.calledOnceWith({
+      headers: {
+        Authorization: 'Bearer custom-read-batch-token',
+      },
+    })
+  })
+
+  test('should throw an error if API returns a non-200 status (e.g., 500)', async ({ network, assert }) => {
+    const errorResponse = {
+      message: 'Server Error For Reading User Batch',
+      status: 500,
+      help: 'Try again later.',
+      name: 'UserReadBatchServerError',
+      code: 'E_USER_READ_BATCH_SERVER_ERROR',
+    }
+    await mocker.organizations.users.readBatch(network, {
+      response: {
+        status: 500,
+        body: JSON.stringify(errorResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+
+    const error = await assert.rejects<Exception>(
+      async () => await sdk.organizations.users.readBatch(oid, userKeysToRead),
+      Exception,
+      errorResponse.message
+    )
+    assert.strictEqual(error.name, errorResponse.name)
+    assert.strictEqual(error.code, errorResponse.code)
+    assert.strictEqual(error.status, errorResponse.status)
+  })
+
+  test('should throw an error if API response has no body on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.readBatch(network, {
+      response: {
+        status: 200,
+        body: '',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await assert.rejects(
+      async () => await sdk.organizations.users.readBatch(oid, userKeysToRead),
+      Exception,
+      'Unable to read the user batch info. The response has no value.'
+    )
+  })
+
+  test('should throw an error if API response body is invalid JSON on 200 status', async ({ network, assert }) => {
+    await mocker.organizations.users.readBatch(network, {
+      response: {
+        status: 200,
+        body: 'this is not json for a user batch',
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await assert.rejects(
+      async () => await sdk.organizations.users.readBatch(oid, userKeysToRead),
+      Exception,
+      'Unable to read the user batch info. Invalid JSON response.'
+    )
+  })
+
+  test('should throw an error if API response data is missing "data" array on 200 status', async ({
+    network,
+    assert,
+  }) => {
+    await mocker.organizations.users.readBatch(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify({ notItems: 'something else' }),
+        headers: { 'Content-Type': 'application/json' },
+      },
+    })
+    await assert.rejects(
+      async () => await sdk.organizations.users.readBatch(oid, userKeysToRead),
+      Exception,
+      'Unable to read the user batch info. Unknown response from the server.'
+    )
+  })
+
+  test('should correctly build URL when baseUri has a path', async ({ network }) => {
+    const customBaseUri = 'http://localhost:3000/api/org-batch-user'
+    sdk.baseUri = customBaseUri
+    const handle = await mocker.organizations.users.readBatch(network, {
+      response: {
+        status: 200,
+        body: JSON.stringify(mockSuccessfulResponse),
+        headers: { 'Content-Type': 'application/json' },
+      },
+      baseUri: customBaseUri,
+    })
+    await sdk.organizations.users.readBatch(oid, userKeysToRead)
+    await handle.assert.calledOnceWith({
+      headers: { Authorization: `Bearer ${baseToken}` },
+      body: JSON.stringify({ ids: userKeysToRead }),
+    })
+  })
+})