Drops

curl -G "https://www.membber.com/api/v1/drops" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  --data-urlencode "store_id=6659c139-0000-4000-8000-d0c500000066"

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

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

const { data, error } = await membber.raw.GET("/api/v1/drops", {
  params: { query: { store_id: "6659c139-0000-4000-8000-d0c500000066" } },
});

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.listBatchDrops(
    query: .init(storeId: "6659c139-0000-4000-8000-d0c500000066")
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "store_id": "6659c139-0000-4000-8000-d0c500000066",
    "name": "Example name",
    "opens_at": "<opens_at>",
    "collection_date": "<collection_date>"
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops", {
  body: {
    store_id: "6659c139-0000-4000-8000-d0c500000066",
    name: "Example name",
    opens_at: "<opens_at>",
    collection_date: "<collection_date>"
  },
  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.createBatchDrop(
    body: .json(.init(
        storeId: "6659c139-0000-4000-8000-d0c500000066",
        name: "Example name",
        opensAt: "<opens_at>",
        collectionDate: "<collection_date>"
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/drops/b11f386a-0000-4000-8000-d0c5000000b1" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  --data-urlencode "store_id=6659c139-0000-4000-8000-d0c500000066"

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

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

const { data, error } = await membber.raw.GET("/api/v1/drops/{dropId}", {
  params: { path: { dropId: "b11f386a-0000-4000-8000-d0c5000000b1" }, query: { store_id: "6659c139-0000-4000-8000-d0c500000066" } },
});

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.getBatchDrop(
    path: .init(dropId: "b11f386a-0000-4000-8000-d0c5000000b1"),
    query: .init(storeId: "6659c139-0000-4000-8000-d0c500000066")
).ok.body.json

print(response)

curl -X PATCH "https://www.membber.com/api/v1/drops/b11f386a-0000-4000-8000-d0c5000000b1" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "store_id": "6659c139-0000-4000-8000-d0c500000066"
  }'

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

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

const { data, error } = await membber.raw.PATCH("/api/v1/drops/{dropId}", {
  params: { path: { dropId: "b11f386a-0000-4000-8000-d0c5000000b1" } },
  body: {
    store_id: "6659c139-0000-4000-8000-d0c500000066"
  },
  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.updateBatchDrop(
    path: .init(dropId: "b11f386a-0000-4000-8000-d0c5000000b1"),
    body: .json(.init(
        storeId: "6659c139-0000-4000-8000-d0c500000066"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops/b11f386a-0000-4000-8000-d0c5000000b1/cancel" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "store_id": "6659c139-0000-4000-8000-d0c500000066"
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops/{dropId}/cancel", {
  params: { path: { dropId: "b11f386a-0000-4000-8000-d0c5000000b1" } },
  body: {
    store_id: "6659c139-0000-4000-8000-d0c500000066"
  },
  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.cancelBatchDrop(
    path: .init(dropId: "b11f386a-0000-4000-8000-d0c5000000b1"),
    body: .json(.init(
        storeId: "6659c139-0000-4000-8000-d0c500000066"
    ))
).ok.body.json

print(response)

curl -X PUT "https://www.membber.com/api/v1/drops/b11f386a-0000-4000-8000-d0c5000000b1/items" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "store_id": "6659c139-0000-4000-8000-d0c500000066",
    "items": [
      {
        "menu_item_id": "ca65a6e7-0000-4000-8000-d0c5000000ca",
        "quantity": 1
      }
    ]
  }'

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

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

const { data, error } = await membber.raw.PUT("/api/v1/drops/{dropId}/items", {
  params: { path: { dropId: "b11f386a-0000-4000-8000-d0c5000000b1" } },
  body: {
    store_id: "6659c139-0000-4000-8000-d0c500000066",
    items: [
      {
        menu_item_id: "ca65a6e7-0000-4000-8000-d0c5000000ca",
        quantity: 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.setBatchDropItems(
    path: .init(dropId: "b11f386a-0000-4000-8000-d0c5000000b1"),
    body: .json(.init(
        storeId: "6659c139-0000-4000-8000-d0c500000066",
        items: [.init(
            menuItemId: "ca65a6e7-0000-4000-8000-d0c5000000ca",
            quantity: 1
        )]
    ))
).ok.body.json

print(response)

curl -X PUT "https://www.membber.com/api/v1/drops/b11f386a-0000-4000-8000-d0c5000000b1/windows" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "store_id": "6659c139-0000-4000-8000-d0c500000066",
    "windows": [
      {
        "starts_at": "<starts_at>",
        "ends_at": "<ends_at>"
      }
    ]
  }'

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

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

const { data, error } = await membber.raw.PUT("/api/v1/drops/{dropId}/windows", {
  params: { path: { dropId: "b11f386a-0000-4000-8000-d0c5000000b1" } },
  body: {
    store_id: "6659c139-0000-4000-8000-d0c500000066",
    windows: [
      {
        starts_at: "<starts_at>",
        ends_at: "<ends_at>"
      }
    ]
  },
  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.setBatchDropWindows(
    path: .init(dropId: "b11f386a-0000-4000-8000-d0c5000000b1"),
    body: .json(.init(
        storeId: "6659c139-0000-4000-8000-d0c500000066",
        windows: [.init(
            startsAt: "<starts_at>",
            endsAt: "<ends_at>"
        )]
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops/message/<handle>" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "alex@example.com",
    "message": "Added at the front desk"
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops/message/{handle}", {
  params: { path: { handle: "<handle>" } },
  body: {
    email: "alex@example.com",
    message: "Added at the front desk"
  },
  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.startDropMessage(
    path: .init(handle: "<handle>"),
    body: .json(.init(
        email: "alex@example.com",
        message: "Added at the front desk"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops/message/<handle>/verify" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "email": "alex@example.com",
    "code": "EXAMPLE10"
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops/message/{handle}/verify", {
  params: { path: { handle: "<handle>" } },
  body: {
    email: "alex@example.com",
    code: "EXAMPLE10"
  },
  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.verifyDropMessage(
    path: .init(handle: "<handle>"),
    body: .json(.init(
        email: "alex@example.com",
        code: "EXAMPLE10"
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops/payment" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "store_code": "EXAMPLE10",
    "idempotency_key": "1f0e2d3c-4b5a-4678-9abc-def012345678",
    "batch_drop_id": "63a4cc66-0000-4000-8000-d0c500000063",
    "cart_token": "<cart_token>",
    "order_type": "<order_type>",
    "collection_mode": "<collection_mode>",
    "items": [
      {
        "menu_item_id": "ca65a6e7-0000-4000-8000-d0c5000000ca",
        "quantity": 1
      }
    ],
    "customer": {
      "name": "Example name",
      "phone": "+44 7700 900123"
    }
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops/payment", {
  body: {
    store_code: "EXAMPLE10",
    idempotency_key: "1f0e2d3c-4b5a-4678-9abc-def012345678",
    batch_drop_id: "63a4cc66-0000-4000-8000-d0c500000063",
    cart_token: "<cart_token>",
    order_type: "<order_type>",
    collection_mode: "<collection_mode>",
    items: [
      {
        menu_item_id: "ca65a6e7-0000-4000-8000-d0c5000000ca",
        quantity: 1
      }
    ],
    customer: {
      name: "Example name",
      phone: "+44 7700 900123"
    }
  },
  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.startDropPayment(
    body: .json(.init(
        storeCode: "EXAMPLE10",
        idempotencyKey: "1f0e2d3c-4b5a-4678-9abc-def012345678",
        batchDropId: "63a4cc66-0000-4000-8000-d0c500000063",
        cartToken: "<cart_token>",
        orderType: "<order_type>",
        collectionMode: "<collection_mode>",
        items: [.init(
            menuItemId: "ca65a6e7-0000-4000-8000-d0c5000000ca",
            quantity: 1
        )],
        customer: .init(
            name: "Example name",
            phone: "+44 7700 900123"
        )
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/drops/public/EXAMPLE10" \
  -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/drops/public/{dropCode}", {
  params: { path: { dropCode: "EXAMPLE10" } },
});

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.getPublicBatchDrop(
    path: .init(dropCode: "EXAMPLE10")
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops/public/EXAMPLE10/hold" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "cart_token": "<cart_token>",
    "item_id": "7e22b9c7-0000-4000-8000-d0c50000007e",
    "quantity": 1
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops/public/{dropCode}/hold", {
  params: { path: { dropCode: "EXAMPLE10" } },
  body: {
    cart_token: "<cart_token>",
    item_id: "7e22b9c7-0000-4000-8000-d0c50000007e",
    quantity: 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.holdBatchDropCart(
    path: .init(dropCode: "EXAMPLE10"),
    body: .json(.init(
        cartToken: "<cart_token>",
        itemId: "7e22b9c7-0000-4000-8000-d0c50000007e",
        quantity: 1
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops/public/EXAMPLE10/release" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "drop_code": "EXAMPLE10",
    "cart_token": "<cart_token>"
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops/public/{dropCode}/release", {
  params: { path: { dropCode: "EXAMPLE10" } },
  body: {
    drop_code: "EXAMPLE10",
    cart_token: "<cart_token>"
  },
  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.releaseBatchDropCart(
    path: .init(dropCode: "EXAMPLE10"),
    body: .json(.init(
        dropCode: "EXAMPLE10",
        cartToken: "<cart_token>"
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/drops/shop" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  --data-urlencode "store_id=6659c139-0000-4000-8000-d0c500000066"

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

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

const { data, error } = await membber.raw.GET("/api/v1/drops/shop", {
  params: { query: { store_id: "6659c139-0000-4000-8000-d0c500000066" } },
});

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.getDropsShop(
    query: .init(storeId: "6659c139-0000-4000-8000-d0c500000066")
).ok.body.json

print(response)

curl -X PUT "https://www.membber.com/api/v1/drops/shop" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "store_id": "6659c139-0000-4000-8000-d0c500000066",
    "bg_mode": "plain"
  }'

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

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

const { data, error } = await membber.raw.PUT("/api/v1/drops/shop", {
  body: {
    store_id: "6659c139-0000-4000-8000-d0c500000066",
    bg_mode: "plain"
  },
  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.updateDropsShop(
    body: .json(.init(
        storeId: "6659c139-0000-4000-8000-d0c500000066",
        bgMode: .plain
    ))
).ok.body.json

print(response)

curl -G "https://www.membber.com/api/v1/drops/shop/media" \
  -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/drops/shop/media");

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.listShopMedia().ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops/shop/media" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://example.com/image.jpg",
    "media_type": "image"
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops/shop/media", {
  body: {
    url: "https://example.com/image.jpg",
    media_type: "image"
  },
  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.addShopMedia(
    body: .json(.init(
        url: "https://example.com/image.jpg",
        mediaType: .image
    ))
).ok.body.json

print(response)

curl -X DELETE "https://www.membber.com/api/v1/drops/shop/media/3813101f-0000-4000-8000-d0c500000038?mediaId=3813101f-0000-4000-8000-d0c500000038" \
  -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/drops/shop/media/{mediaId}", {
  params: { path: { mediaId: "3813101f-0000-4000-8000-d0c500000038" }, query: { mediaId: "3813101f-0000-4000-8000-d0c500000038" } },
  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.deleteShopMedia(
    path: .init(mediaId: "3813101f-0000-4000-8000-d0c500000038"),
    query: .init(mediaId: "3813101f-0000-4000-8000-d0c500000038")
).ok.body.json

print(response)

curl -X PUT "https://www.membber.com/api/v1/drops/shop/media/order" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "ids": [
      "00000d1b-0000-4000-8000-d0c500000000"
    ]
  }'

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

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

const { data, error } = await membber.raw.PUT("/api/v1/drops/shop/media/order", {
  body: {
    ids: [
      "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.reorderShopMedia(
    body: .json(.init(
        ids: ["00000d1b-0000-4000-8000-d0c500000000"]
    ))
).ok.body.json

print(response)

curl -X POST "https://www.membber.com/api/v1/drops/subscribe/<handle>" \
  -H "Authorization: Bearer $MEMBBER_TOKEN" \
  -H "Idempotency-Key: 1f0e2d3c-4b5a-4678-9abc-def012345678" \
  -H "Content-Type: application/json" \
  -d '{
    "handle": "<handle>",
    "phone": "+44 7700 900123",
    "email": "alex@example.com",
    "consent_text": "<consent_text>"
  }'

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

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

const { data, error } = await membber.raw.POST("/api/v1/drops/subscribe/{handle}", {
  params: { path: { handle: "<handle>" } },
  body: {
    handle: "<handle>",
    phone: "+44 7700 900123",
    email: "alex@example.com",
    consent_text: "<consent_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.subscribeToDrops(
    path: .init(handle: "<handle>"),
    body: .json(.init(
        handle: "<handle>",
        phone: "+44 7700 900123",
        email: "alex@example.com",
        consentText: "<consent_text>"
    ))
).ok.body.json

print(response)