Enabling interoperable trust ecosystems

const api = new IssuanceApi(new Configuration({
  apiKey: authProvider.fetchProjectScopedToken.bind(authProvider)
}));

config = Configuration()
config.api_key['ProjectTokenAuth'] = project_token
api = IssuanceApi(ApiClient(config))

$config = CredentialIssuanceClient\Configuration
    ::getDefaultConfiguration()
    ->setApiKey('authorization', '', $tokenCallback);
$api = new CredentialIssuanceClient\Api\IssuanceApi(
    new GuzzleHttp\Client(), $config
);

ApiClient client = Configuration.getDefaultApiClient();
((ApiKeyAuth) client.getAuthentication("ProjectTokenAuth"))
    .setApiKey(authProvider.fetchProjectScopedToken());
IssuanceApi api = new IssuanceApi(client);

final client = AffinidiTdkCredentialIssuanceClient(
  dio: Dio(BaseOptions(
    baseUrl: AffinidiTdkCredentialIssuanceClient.basePath
  )),
  authTokenHook: authProvider.fetchProjectScopedToken
);
final api = client.getIssuanceApi();

var config = new Configuration();
config.AddApiKey("authorization", projectScopedToken);
var api = new IssuanceApi(config);

let tdk = TDK::new(
    TDKConfig::builder()
        .with_environment_name(env_name)
        .build()?,
    None,
).await?;
let atm = tdk.atm.clone().unwrap();

const response = await api.startIssuance(projectId, {
  data: [{
    credentialTypeId: "EmploymentCredential",
    credentialData: { employer: "Acme Corp" }
  }],
  holderDid: "did:key:...",
  claimMode: "FIXED_HOLDER"
});

request = StartIssuanceInput.from_dict({
    "data": [{
        "credentialTypeId": "EmploymentCredential",
        "credentialData": {"employer": "Acme Corp"}
    }],
    "holderDid": "did:key:...",
    "claimMode": "FIXED_HOLDER"
})
response = api.start_issuance(project_id, request)

$result = $api->startIssuance($projectId, [
    "data" => [[
        "credentialTypeId" => "EmploymentCredential",
        "credentialData" => ["employer" => "Acme Corp"]
    ]],
    "holderDid" => "did:key:...",
    "claimMode" => "FIXED_HOLDER"
]);

StartIssuanceInput input = new StartIssuanceInput()
    .claimMode(ClaimModeEnum.TX_CODE)
    .data(List.of(new StartIssuanceInputDataInner()
       .credentialTypeId("EmploymentCredential")
       .credentialData(Map.of("employer", "Acme Corp"))
    ));

StartIssuanceResponse response =
    api.startIssuance(projectId, input);

final input = StartIssuanceInputBuilder()
  ..holderDid = "did:key:..."
  ..claimMode = StartIssuanceInputClaimModeEnum.FIXED_HOLDER
  ..data = ListBuilder([
    StartIssuanceInputDataInner((b) => b
      ..credentialTypeId = "EmploymentCredential"
      ..credentialData = {"employer": "Acme Corp"})
  ]);
final response = await api.startIssuance(
  projectId: projectId,
  startIssuanceInput: input.build()
);

var input = new StartIssuanceInput(
    claimMode: StartIssuanceInput.ClaimModeEnum.TXCODE,
    data: [new StartIssuanceInputDataInner(
        credentialTypeId: "EmploymentCredential",
        credentialData: new Dictionary<string, object> {
            { "employer", "Acme Corp" }
        }
    )]
);
var result = api.StartIssuance(projectId, input);

let msg = Message::build(
    Uuid::new_v4().into(),
    "app_type".into(),
    json!("Hello from Rust!"),
)
.to(recipient_did)
.from(sender_did)
.finalize();

let packed_msg = atm
    .pack_encrypted(
      &msg,
      &to_did,
      Some(&from_did),
      Some(&from_did),
      None
    ).await?;