Board

curl -G "https://www.membber.com/api/v1/board/activity" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/activity");

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.listBoardActivity().ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/candidates" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/candidates");

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.getBoardCandidates().ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/claim" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "id": "00000d1b-0000-4000-8000-d0c500000000",
    "session": "<session>",
    "assignee": "<assignee>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/claim", {
  body: {
    id: "00000d1b-0000-4000-8000-d0c500000000",
    session: "<session>",
    assignee: "<assignee>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.claimBoardTicket(
    body: .json(.init(
        id: "00000d1b-0000-4000-8000-d0c500000000",
        session: "<session>",
        assignee: "<assignee>"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/diagnostics/hang" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "screen": "<screen>",
    "source": "watchdog",
    "seconds": 0,
    "device_class": "<device_class>",
    "app_build": "<app_build>",
    "source_key": "<source_key>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/diagnostics/hang", {
  body: {
    screen: "<screen>",
    source: "watchdog",
    seconds: 0,
    device_class: "<device_class>",
    app_build: "<app_build>",
    source_key: "<source_key>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.reportBoardHang(
    body: .json(.init(
        screen: "<screen>",
        source: .watchdog,
        seconds: 0,
        deviceClass: "<device_class>",
        appBuild: "<app_build>",
        sourceKey: "<source_key>"
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/fleet" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/fleet");

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.getBoardFleet().ok.body.json

print(response)

curl -X DELETE "https://www.membber.com/api/v1/board/fleet/focus" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.DELETE("/api/v1/board/fleet/focus", {
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.releaseBoardFleetFocus().ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/fleet/focus" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "area": "<area>",
    "merchant": "<merchant>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/fleet/focus", {
  body: {
    area: "<area>",
    merchant: "<merchant>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.pointBoardFleetFocus(
    body: .json(.init(
        area: "<area>",
        merchant: "<merchant>"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/fleet/target" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "target_size": 0
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/fleet/target", {
  body: {
    target_size: 0
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.setBoardFleetTarget(
    body: .json(.init(
        targetSize: 0
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/fleet/wake" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/fleet/wake", {
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.wakeBoardFleet().ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/inbox" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/inbox");

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.listBoardInbox().ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/inbox" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Morning class"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/inbox", {
  body: {
    title: "Morning class"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.raiseBoardDecision(
    body: .json(.init(
        title: "Morning class"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/inbox/00000d1b-0000-4000-8000-d0c500000000/answer" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "option_key": "<option_key>",
    "option_keys": [
      "<option_key>"
    ],
    "text": "<text>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/inbox/{id}/answer", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
  body: {
    option_key: "<option_key>",
    option_keys: [
      "<option_key>"
    ],
    text: "<text>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.answerBoardInbox(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000"),
    body: .json(.init(
        optionKey: "<option_key>",
        optionKeys: ["<option_key>"],
        text: "<text>"
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/inbox/00000d1b-0000-4000-8000-d0c500000000/attachments" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/inbox/{id}/attachments", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.listBoardInboxAttachments(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000")
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/inbox/00000d1b-0000-4000-8000-d0c500000000/attachments" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '"<value>"'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/inbox/{id}/attachments", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
  body: "<value>",
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.attachBoardInboxMedia(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000"),
    body: .json("<value>")
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/inbox/00000d1b-0000-4000-8000-d0c500000000/attachments/upload-url" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "kind": "image",
    "content_type": "<content_type>",
    "byte_size": 1
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/inbox/{id}/attachments/upload-url", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
  body: {
    kind: "image",
    content_type: "<content_type>",
    byte_size: 1
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.createBoardInboxUploadUrl(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000"),
    body: .json(.init(
        kind: .image,
        contentType: "<content_type>",
        byteSize: 1
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/inbox/00000d1b-0000-4000-8000-d0c500000000/chat" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "text": "<text>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/inbox/{id}/chat", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
  body: {
    text: "<text>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.chatBoardInbox(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000"),
    body: .json(.init(
        text: "<text>"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/inbox/00000d1b-0000-4000-8000-d0c500000000/triage" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "section": "<section>",
    "priority": "<priority>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/inbox/{id}/triage", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
  body: {
    section: "<section>",
    priority: "<priority>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.triageBoardInbox(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000"),
    body: .json(.init(
        section: "<section>",
        priority: "<priority>"
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/sections/order" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/sections/order");

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.getBoardSectionOrder().ok.body.json

print(response)

curl -X PUT "https://www.membber.com/api/v1/board/sections/order" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "order": [
      "<order>"
    ]
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.PUT("/api/v1/board/sections/order", {
  body: {
    order: [
      "<order>"
    ]
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.setBoardSectionOrder(
    body: .json(.init(
        order: ["<order>"]
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/session" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "alex@example.com",
    "password": "<password>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/session", {
  body: {
    email: "alex@example.com",
    password: "<password>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.boardLogin(
    body: .json(.init(
        email: "alex@example.com",
        password: "<password>"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/session/apple" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "identityToken": "<identityToken>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/session/apple", {
  body: {
    identityToken: "<identityToken>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.boardLoginApple(
    body: .json(.init(
        identityToken: "<identityToken>"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/session/google" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "credential": "<credential>"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/session/google", {
  body: {
    credential: "<credential>"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.boardLoginGoogle(
    body: .json(.init(
        credential: "<credential>"
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/sessions" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/sessions");

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.listBoardSessions().ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/sessions/00000d1b-0000-4000-8000-d0c500000000/finish" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/sessions/{id}/finish", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.finishBoardSession(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000")
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/sessions/00000d1b-0000-4000-8000-d0c500000000/history" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/sessions/{id}/history", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.getBoardSessionHistory(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000")
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/sessions/00000d1b-0000-4000-8000-d0c500000000/next" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/sessions/{id}/next", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.getBoardSessionNext(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000")
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/sessions/00000d1b-0000-4000-8000-d0c500000000/views" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/sessions/{id}/views", {
  params: { path: { id: "00000d1b-0000-4000-8000-d0c500000000" } },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.listBoardSessionViews(
    path: .init(id: "00000d1b-0000-4000-8000-d0c500000000")
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/sessions/heartbeat" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "session_id": "630ddf64-0000-4000-8000-d0c500000063"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/sessions/heartbeat", {
  body: {
    session_id: "630ddf64-0000-4000-8000-d0c500000063"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.boardSessionHeartbeat(
    body: .json(.init(
        sessionId: "630ddf64-0000-4000-8000-d0c500000063"
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/board/spawn" \
  -H "Authorization: Bearer $MEMBBER_TOKEN"

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.GET("/api/v1/board/spawn");

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.listBoardSpawnRequests().ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/board/spawn" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "section": "<section>",
    "ticket_id": "fbc29b2e-0000-4000-8000-d0c5000000fb",
    "instructions": "<instructions>",
    "client_request_id": "8e99e5bf-0000-4000-8000-d0c50000008e"
  }'

import { createMembberClient } from "@membber/sdk-ts";

const membber = createMembberClient({
  getAccessToken: () => process.env.MEMBBER_TOKEN,
});

const { data, error } = await membber.raw.POST("/api/v1/board/spawn", {
  body: {
    section: "<section>",
    ticket_id: "fbc29b2e-0000-4000-8000-d0c5000000fb",
    instructions: "<instructions>",
    client_request_id: "8e99e5bf-0000-4000-8000-d0c50000008e"
  },
  headers: { "Idempotency-Key": crypto.randomUUID() },
});

if (error) {
  // Typed error envelope: { error: { code, message, requestId } }
  throw new Error(`${error.error.code}: ${error.error.message}`);
}
console.log(data);

import MembberSwift

let client = MembberClient(
    serverURL: MembberClient.productionServerURL,
    tokenProvider: { session.accessToken }
)

let response = try await client.api.spawnBoardDeveloper(
    body: .json(.init(
        section: "<section>",
        ticketId: "fbc29b2e-0000-4000-8000-d0c5000000fb",
        instructions: "<instructions>",
        clientRequestId: "8e99e5bf-0000-4000-8000-d0c50000008e"
    ))
).ok.body.json

print(response)