using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.DeviceCredentials.CreatePublicKeyAsync(
            new CreatePublicKeyDeviceCredentialRequestContent {
                DeviceName = "device_name",
                Type = DeviceCredentialPublicKeyTypeEnum.PublicKey,
                Value = "value",
                DeviceId = "device_id"
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.CreatePublicKeyDeviceCredentialRequestContent{
        DeviceName: "device_name",
        Type: management.DeviceCredentialPublicKeyTypeEnum(
            "public_key",
        ),
        Value: "value",
        DeviceId: "device_id",
    }
    mgmt.DeviceCredentials.CreatePublicKey(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.CreatePublicKeyDeviceCredentialRequestContent;
import com.auth0.client.mgmt.types.DeviceCredentialPublicKeyTypeEnum;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.deviceCredentials().createPublicKey(
            CreatePublicKeyDeviceCredentialRequestContent
                .builder()
                .deviceName("device_name")
                .type(DeviceCredentialPublicKeyTypeEnum.PUBLIC_KEY)
                .value("value")
                .deviceId("device_id")
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\DeviceCredentials\Requests\CreatePublicKeyDeviceCredentialRequestContent;
use Auth0\SDK\API\Management\Types\DeviceCredentialPublicKeyTypeEnum;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->deviceCredentials->createPublicKey(
    new CreatePublicKeyDeviceCredentialRequestContent([
        'deviceName' => 'device_name',
        'type' => DeviceCredentialPublicKeyTypeEnum::PublicKey->value,
        'value' => 'value',
        'deviceId' => 'device_id',
    ]),
);

from auth0.management import ManagementClient

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.device_credentials.create_public_key(
    device_name="device_name",
    type="public_key",
    value="value",
    device_id="device_id",
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.device_credentials.create_public_key(
  device_name: "device_name",
  type: "public_key",
  value: "value",
  device_id: "device_id"
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.deviceCredentials.createPublicKey({
        deviceName: "device_name",
        type: "public_key",
        value: "value",
        deviceId: "device_id",
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.deviceCredentials.createPublicKey({
        deviceName: "device_name",
        type: "public_key",
        value: "value",
        deviceId: "device_id",
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/device-credentials \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "device_id": "<string>",
  "device_name": "<string>",
  "type": "public_key",
  "value": "<string>",
  "client_id": "<string>"
}
'

{
  "id": "dcr_0000000000000001"
}

デバイス資格情報のPost

指定された user_id のリフレッシュトークンのローテーションを管理するためのデバイス資格情報の公開鍵を作成します。Device Credentials API は、臨時の管理用途でのみ使用することを想定して設計されており、GET リクエストではデフォルトでページングが有効になっています。

リフレッシュトークンのローテーションが有効な場合、このエンドポイントは結果整合性を持つようになります。詳細は、Signing Keys を参照してください。

POST

https://{tenantDomain}/api/v2

device-credentials

using Auth0.ManagementApi;
using System.Threading.Tasks;

public partial class Examples
{
    public async Task Example() {
        var client = new ManagementApiClient(
            token: "<token>",
            clientOptions: new ClientOptions { BaseUrl = "https://{YOUR_DOMAIN}/api/v2" }
        );

        await client.DeviceCredentials.CreatePublicKeyAsync(
            new CreatePublicKeyDeviceCredentialRequestContent {
                DeviceName = "device_name",
                Type = DeviceCredentialPublicKeyTypeEnum.PublicKey,
                Value = "value",
                DeviceId = "device_id"
            }
        );
    }

}

package example

import (
    context "context"

    management "github.com/auth0/go-auth0/v3/management"
    client "github.com/auth0/go-auth0/v3/management/client"
    option "github.com/auth0/go-auth0/v3/management/option"
)

func do() {
    mgmt, err := client.New(
        "{YOUR_DOMAIN}",
        option.WithToken(
            "<token>",
        ),
    )
    if err != nil {
        return
    }
    request := &management.CreatePublicKeyDeviceCredentialRequestContent{
        DeviceName: "device_name",
        Type: management.DeviceCredentialPublicKeyTypeEnum(
            "public_key",
        ),
        Value: "value",
        DeviceId: "device_id",
    }
    mgmt.DeviceCredentials.CreatePublicKey(
        context.TODO(),
        request,
    )
}

package com.example.usage;

import com.auth0.client.mgmt.ManagementApi;
import com.auth0.client.mgmt.types.CreatePublicKeyDeviceCredentialRequestContent;
import com.auth0.client.mgmt.types.DeviceCredentialPublicKeyTypeEnum;

public class Example {
    public static void main(String[] args) {
        ManagementApi client = ManagementApi
            .builder()
            .domain("{YOUR_DOMAIN}")
            .token("<token>")
            .build();

        client.deviceCredentials().createPublicKey(
            CreatePublicKeyDeviceCredentialRequestContent
                .builder()
                .deviceName("device_name")
                .type(DeviceCredentialPublicKeyTypeEnum.PUBLIC_KEY)
                .value("value")
                .deviceId("device_id")
                .build()
        );
    }
}

<?php

namespace Example;

use Auth0\SDK\API\Management\Wrapper\ManagementClient;
use Auth0\SDK\API\Management\Wrapper\ManagementClientOptions;
use Auth0\SDK\API\Management\DeviceCredentials\Requests\CreatePublicKeyDeviceCredentialRequestContent;
use Auth0\SDK\API\Management\Types\DeviceCredentialPublicKeyTypeEnum;

$client = new ManagementClient(new ManagementClientOptions(
    domain: '{YOUR_DOMAIN}',
    token: '<token>',
));
$client->deviceCredentials->createPublicKey(
    new CreatePublicKeyDeviceCredentialRequestContent([
        'deviceName' => 'device_name',
        'type' => DeviceCredentialPublicKeyTypeEnum::PublicKey->value,
        'value' => 'value',
        'deviceId' => 'device_id',
    ]),
);

from auth0.management import ManagementClient

client = ManagementClient(
    domain="{YOUR_DOMAIN}",
    token="<token>",
)

client.device_credentials.create_public_key(
    device_name="device_name",
    type="public_key",
    value="value",
    device_id="device_id",
)

require "auth0"

client = Auth0::Management.new(token: "<token>", base_url: "https://{YOUR_DOMAIN}/api/v2")

client.device_credentials.create_public_key(
  device_name: "device_name",
  type: "public_key",
  value: "value",
  device_id: "device_id"
)

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.deviceCredentials.createPublicKey({
        deviceName: "device_name",
        type: "public_key",
        value: "value",
        deviceId: "device_id",
    });
}
main();

import { ManagementClient } from "auth0";

async function main() {
    const client = new ManagementClient({
        domain: "{YOUR_DOMAIN}",
        token: "<token>",
    });
    await client.deviceCredentials.createPublicKey({
        deviceName: "device_name",
        type: "public_key",
        value: "value",
        deviceId: "device_id",
    });
}
main();

curl --request POST \
  --url https://{tenantDomain}/api/v2/device-credentials \
  --header 'Authorization: Bearer <token>' \
  --header 'Content-Type: application/json' \
  --data '
{
  "device_id": "<string>",
  "device_name": "<string>",
  "type": "public_key",
  "value": "<string>",
  "client_id": "<string>"
}
'

{
  "id": "dcr_0000000000000001"
}

承認

Authorization

string

header

必須

Bearer authentication header of the form Bearer <token>, where <token> is your auth token.

ボディ

device_id

string

必須

デバイスの一意の識別子。AndroidではAndroid_ID、iOSではidentifierForVendorの使用を推奨します。

Maximum string length: 36

Pattern: ^[-A-Fa-f0-9]+$

device_name

string

必須

所有者が簡単に識別できる、このデバイスの名前。

Minimum string length: 1

type

enum<string>

必須

資格情報の種類。public_key でなければなりません。

利用可能なオプション:

public_key

value

string

必須

credentialを含むBase64エンコード文字列。

Minimum string length: 1

client_id

string<client-id>

このcredentialの対象であるクライアント（アプリケーション）のclient_id。

レスポンス

デバイス資格情報が正常に作成されました。

string

デフォルト:dcr_0000000000000001

必須

credentialの識別子。