authentik.RbacPermissionUser

import * as pulumi from "@pulumi/pulumi";
import * as authentik from "@pulumi/authentik";

// Assign a global permission to a user
const nameUser = new authentik.User("nameUser", {username: "user"});
const global_permissionRbacPermissionUser = new authentik.RbacPermissionUser("global-permissionRbacPermissionUser", {
    user: nameUser.userId,
    permission: "authentik_flows.inspect_flow",
});
// Assign an object permission to a user
const flow = new authentik.Flow("flow", {
    title: "Test flow",
    slug: "test-flow",
    designation: "authorization",
});
const nameIndex_userUser = new authentik.User("nameIndex/userUser", {username: "user"});
const global_permissionIndex_rbacPermissionUserRbacPermissionUser = new authentik.RbacPermissionUser("global-permissionIndex/rbacPermissionUserRbacPermissionUser", {
    user: nameUser.userId,
    model: "authentik_flows.flow",
    permission: "inspect_flow",
    objectId: flow.uuid,
});

import pulumi
import pulumi_authentik as authentik

# Assign a global permission to a user
name_user = authentik.User("nameUser", username="user")
global_permission_rbac_permission_user = authentik.RbacPermissionUser("global-permissionRbacPermissionUser",
    user=name_user.user_id,
    permission="authentik_flows.inspect_flow")
# Assign an object permission to a user
flow = authentik.Flow("flow",
    title="Test flow",
    slug="test-flow",
    designation="authorization")
name_index_user_user = authentik.User("nameIndex/userUser", username="user")
global_permission_index_rbac_permission_user_rbac_permission_user = authentik.RbacPermissionUser("global-permissionIndex/rbacPermissionUserRbacPermissionUser",
    user=name_user.user_id,
    model="authentik_flows.flow",
    permission="inspect_flow",
    object_id=flow.uuid)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/authentik/v2025/authentik"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Assign a global permission to a user
		nameUser, err := authentik.NewUser(ctx, "nameUser", &authentik.UserArgs{
			Username: pulumi.String("user"),
		})
		if err != nil {
			return err
		}
		_, err = authentik.NewRbacPermissionUser(ctx, "global-permissionRbacPermissionUser", &authentik.RbacPermissionUserArgs{
			User:       nameUser.UserId,
			Permission: pulumi.String("authentik_flows.inspect_flow"),
		})
		if err != nil {
			return err
		}
		flow, err := authentik.NewFlow(ctx, "flow", &authentik.FlowArgs{
			Title:       pulumi.String("Test flow"),
			Slug:        pulumi.String("test-flow"),
			Designation: pulumi.String("authorization"),
		})
		if err != nil {
			return err
		}
		_, err = authentik.NewUser(ctx, "nameIndex/userUser", &authentik.UserArgs{
			Username: pulumi.String("user"),
		})
		if err != nil {
			return err
		}
		_, err = authentik.NewRbacPermissionUser(ctx, "global-permissionIndex/rbacPermissionUserRbacPermissionUser", &authentik.RbacPermissionUserArgs{
			User:       nameUser.UserId,
			Model:      pulumi.String("authentik_flows.flow"),
			Permission: pulumi.String("inspect_flow"),
			ObjectId:   flow.Uuid,
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Authentik = Pulumi.Authentik;

return await Deployment.RunAsync(() => 
{
    // Assign a global permission to a user
    var nameUser = new Authentik.User("nameUser", new()
    {
        Username = "user",
    });

    var global_permissionRbacPermissionUser = new Authentik.RbacPermissionUser("global-permissionRbacPermissionUser", new()
    {
        User = nameUser.UserId,
        Permission = "authentik_flows.inspect_flow",
    });

    // Assign an object permission to a user
    var flow = new Authentik.Flow("flow", new()
    {
        Title = "Test flow",
        Slug = "test-flow",
        Designation = "authorization",
    });

    var nameIndex_userUser = new Authentik.User("nameIndex/userUser", new()
    {
        Username = "user",
    });

    var global_permissionIndex_rbacPermissionUserRbacPermissionUser = new Authentik.RbacPermissionUser("global-permissionIndex/rbacPermissionUserRbacPermissionUser", new()
    {
        User = nameUser.UserId,
        Model = "authentik_flows.flow",
        Permission = "inspect_flow",
        ObjectId = flow.Uuid,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.authentik.User;
import com.pulumi.authentik.UserArgs;
import com.pulumi.authentik.RbacPermissionUser;
import com.pulumi.authentik.RbacPermissionUserArgs;
import com.pulumi.authentik.Flow;
import com.pulumi.authentik.FlowArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        // Assign a global permission to a user
        var nameUser = new User("nameUser", UserArgs.builder()
            .username("user")
            .build());

        var global_permissionRbacPermissionUser = new RbacPermissionUser("global-permissionRbacPermissionUser", RbacPermissionUserArgs.builder()
            .user(nameUser.userId())
            .permission("authentik_flows.inspect_flow")
            .build());

        // Assign an object permission to a user
        var flow = new Flow("flow", FlowArgs.builder()
            .title("Test flow")
            .slug("test-flow")
            .designation("authorization")
            .build());

        var nameIndex_userUser = new User("nameIndex/userUser", UserArgs.builder()
            .username("user")
            .build());

        var global_permissionIndex_rbacPermissionUserRbacPermissionUser = new RbacPermissionUser("global-permissionIndex/rbacPermissionUserRbacPermissionUser", RbacPermissionUserArgs.builder()
            .user(nameUser.userId())
            .model("authentik_flows.flow")
            .permission("inspect_flow")
            .objectId(flow.uuid())
            .build());

    }
}

resources:
  # Assign a global permission to a user
  nameUser:
    type: authentik:User
    properties:
      username: user
  global-permissionRbacPermissionUser: # Assign an object permission to a user
    type: authentik:RbacPermissionUser
    properties:
      user: ${nameUser.userId}
      permission: authentik_flows.inspect_flow
  flow:
    type: authentik:Flow
    properties:
      title: Test flow
      slug: test-flow
      designation: authorization
  nameIndex/userUser:
    type: authentik:User
    properties:
      username: user
  global-permissionIndex/rbacPermissionUserRbacPermissionUser:
    type: authentik:RbacPermissionUser
    properties:
      user: ${nameUser.userId}
      model: authentik_flows.flow
      permission: inspect_flow
      objectId: ${flow.uuid}

var rbacPermissionUserResource = new Authentik.RbacPermissionUser("rbacPermissionUserResource", new()
{
    Permission = "string",
    User = 0,
    Model = "string",
    ObjectId = "string",
    RbacPermissionUserId = "string",
});

example, err := authentik.NewRbacPermissionUser(ctx, "rbacPermissionUserResource", &authentik.RbacPermissionUserArgs{
	Permission:           pulumi.String("string"),
	User:                 pulumi.Float64(0),
	Model:                pulumi.String("string"),
	ObjectId:             pulumi.String("string"),
	RbacPermissionUserId: pulumi.String("string"),
})

var rbacPermissionUserResource = new RbacPermissionUser("rbacPermissionUserResource", RbacPermissionUserArgs.builder()
    .permission("string")
    .user(0)
    .model("string")
    .objectId("string")
    .rbacPermissionUserId("string")
    .build());

rbac_permission_user_resource = authentik.RbacPermissionUser("rbacPermissionUserResource",
    permission="string",
    user=0,
    model="string",
    object_id="string",
    rbac_permission_user_id="string")

const rbacPermissionUserResource = new authentik.RbacPermissionUser("rbacPermissionUserResource", {
    permission: "string",
    user: 0,
    model: "string",
    objectId: "string",
    rbacPermissionUserId: "string",
});

type: authentik:RbacPermissionUser
properties:
    model: string
    objectId: string
    permission: string
    rbacPermissionUserId: string
    user: 0