@dfns/sdk 0.2.4 → 0.2.5

package/codegen/Permissions/DelegatedPermissionsClient.d.ts

@@ -0,0 +1,27 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedPermissionsClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    createPermissionInit(request: T.CreatePermissionRequest): Promise<UserActionChallengeResponse>;
+    createPermissionComplete(request: T.CreatePermissionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePermissionResponse>;
+    updatePermissionInit(request: T.UpdatePermissionRequest): Promise<UserActionChallengeResponse>;
+    updatePermissionComplete(request: T.UpdatePermissionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePermissionResponse>;
+    archivePermissionInit(request: T.ArchivePermissionRequest): Promise<UserActionChallengeResponse>;
+    archivePermissionComplete(request: T.ArchivePermissionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePermissionResponse>;
+    getPermissionById(request: T.GetPermissionByIdRequest): Promise<T.GetPermissionByIdResponse>;
+    listPermissions(): Promise<T.ListPermissionsResponse>;
+    createPermissionPredicateInit(request: T.CreatePermissionPredicateRequest): Promise<UserActionChallengeResponse>;
+    createPermissionPredicateComplete(request: T.CreatePermissionPredicateRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePermissionPredicateResponse>;
+    updatePermissionPredicateInit(request: T.UpdatePermissionPredicateRequest): Promise<UserActionChallengeResponse>;
+    updatePermissionPredicateComplete(request: T.UpdatePermissionPredicateRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.UpdatePermissionPredicateResponse>;
+    archivePermissionPredicateInit(request: T.ArchivePermissionPredicateRequest): Promise<UserActionChallengeResponse>;
+    archivePermissionPredicateComplete(request: T.ArchivePermissionPredicateRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePermissionPredicateResponse>;
+    listPermissionPredicates(request: T.ListPermissionPredicatesRequest): Promise<T.ListPermissionPredicatesResponse>;
+    createPermissionAssignmentInit(request: T.CreatePermissionAssignmentRequest): Promise<UserActionChallengeResponse>;
+    createPermissionAssignmentComplete(request: T.CreatePermissionAssignmentRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePermissionAssignmentResponse>;
+    revokePermissionAssignmentInit(request: T.RevokePermissionAssignmentRequest): Promise<UserActionChallengeResponse>;
+    revokePermissionAssignmentComplete(request: T.RevokePermissionAssignmentRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.RevokePermissionAssignmentResponse>;
+    listPermissionAssignments(request: T.ListPermissionAssignmentsRequest): Promise<T.ListPermissionAssignmentsResponse>;
+}

package/codegen/Permissions/DelegatedPermissionsClient.js

@@ -0,0 +1,284 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedPermissionsClient = void 0;
+const baseAuthApi_1 = require("../../baseAuthApi");
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class DelegatedPermissionsClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createPermissionInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions', {
+            path: {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async createPermissionComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions', {
+            path: {},
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updatePermissionInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/:permissionId', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async updatePermissionComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/:permissionId', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePermissionInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/:permissionId/archive', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archivePermissionComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/:permissionId/archive', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPermissionById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/:permissionId', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPermissions() {
+        const path = (0, url_1.buildPathAndQuery)('/permissions', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createPermissionPredicateInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async createPermissionPredicateComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updatePermissionPredicateInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates/:predicateId', {
+            path: {
+                permissionId: request.permissionId,
+                predicateId: request.predicateId,
+            },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async updatePermissionPredicateComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates/:predicateId', {
+            path: {
+                permissionId: request.permissionId,
+                predicateId: request.predicateId,
+            },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePermissionPredicateInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates/:predicateId/archive', {
+            path: {
+                permissionId: request.permissionId,
+                predicateId: request.predicateId,
+            },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'PUT',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archivePermissionPredicateComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates/:predicateId/archive', {
+            path: {
+                permissionId: request.permissionId,
+                predicateId: request.predicateId,
+            },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPermissionPredicates(request) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createPermissionAssignmentInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/assignments', {
+            path: {},
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'POST',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify(request.body),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async createPermissionAssignmentComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/assignments', {
+            path: {},
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async revokePermissionAssignmentInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/assignments/:assignmentId', {
+            path: { assignmentId: request.assignmentId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async revokePermissionAssignmentComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/assignments/:assignmentId', {
+            path: { assignmentId: request.assignmentId },
+            query: {},
+        });
+        const { userAction } = await baseAuthApi_1.BaseAuthApi.signUserActionChallenge(signedChallenge, this.apiOptions);
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'DELETE',
+            body: {},
+            headers: { 'x-dfns-useraction': userAction },
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPermissionAssignments(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/assignments', {
+            path: {},
+            query: request.query ?? {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.DelegatedPermissionsClient = DelegatedPermissionsClient;

package/codegen/Permissions/PermissionsClient.d.ts

@@ -0,0 +1,18 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class PermissionsClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    createPermission(request: T.CreatePermissionRequest): Promise<T.CreatePermissionResponse>;
+    updatePermission(request: T.UpdatePermissionRequest): Promise<T.UpdatePermissionResponse>;
+    archivePermission(request: T.ArchivePermissionRequest): Promise<T.ArchivePermissionResponse>;
+    getPermissionById(request: T.GetPermissionByIdRequest): Promise<T.GetPermissionByIdResponse>;
+    listPermissions(): Promise<T.ListPermissionsResponse>;
+    createPermissionPredicate(request: T.CreatePermissionPredicateRequest): Promise<T.CreatePermissionPredicateResponse>;
+    updatePermissionPredicate(request: T.UpdatePermissionPredicateRequest): Promise<T.UpdatePermissionPredicateResponse>;
+    archivePermissionPredicate(request: T.ArchivePermissionPredicateRequest): Promise<T.ArchivePermissionPredicateResponse>;
+    listPermissionPredicates(request: T.ListPermissionPredicatesRequest): Promise<T.ListPermissionPredicatesResponse>;
+    createPermissionAssignment(request: T.CreatePermissionAssignmentRequest): Promise<T.CreatePermissionAssignmentResponse>;
+    revokePermissionAssignment(request: T.RevokePermissionAssignmentRequest): Promise<T.RevokePermissionAssignmentResponse>;
+    listPermissionAssignments(request: T.ListPermissionAssignmentsRequest): Promise<T.ListPermissionAssignmentsResponse>;
+}

package/codegen/Permissions/PermissionsClient.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionsClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class PermissionsClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createPermission(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updatePermission(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/:permissionId', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePermission(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/:permissionId/archive', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPermissionById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/:permissionId', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPermissions() {
+        const path = (0, url_1.buildPathAndQuery)('/permissions', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createPermissionPredicate(request) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updatePermissionPredicate(request) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates/:predicateId', {
+            path: {
+                permissionId: request.permissionId,
+                predicateId: request.predicateId,
+            },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePermissionPredicate(request) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates/:predicateId/archive', {
+            path: {
+                permissionId: request.permissionId,
+                predicateId: request.predicateId,
+            },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPermissionPredicates(request) {
+        const path = (0, url_1.buildPathAndQuery)('/dev-permissions/:permissionId/predicates', {
+            path: { permissionId: request.permissionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createPermissionAssignment(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/assignments', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async revokePermissionAssignment(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/assignments/:assignmentId', {
+            path: { assignmentId: request.assignmentId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPermissionAssignments(request) {
+        const path = (0, url_1.buildPathAndQuery)('/permissions/assignments', {
+            path: {},
+            query: request.query ?? {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.PermissionsClient = PermissionsClient;

package/codegen/Permissions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DelegatedPermissionsClient';
+export * from './PermissionsClient';
+export * from './types';

package/codegen/Permissions/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DelegatedPermissionsClient"), exports);
+__exportStar(require("./PermissionsClient"), exports);
+__exportStar(require("./types"), exports);

package/codegen/Permissions/types.d.ts

@@ -0,0 +1,62 @@
+import * as Permissions from '../datamodel/Permissions';
+export type CreatePermissionRequest = {
+    body: Permissions.CreatePermissionInput;
+};
+export type CreatePermissionResponse = Permissions.Permission;
+export type UpdatePermissionRequest = {
+    permissionId: string;
+    body: Permissions.UpdatePermissionInput;
+};
+export type UpdatePermissionResponse = Permissions.Permission;
+export type ArchivePermissionRequest = {
+    permissionId: string;
+    body: Permissions.ArchivePermissionInput;
+};
+export type ArchivePermissionResponse = Permissions.Permission;
+export type GetPermissionByIdRequest = {
+    permissionId: string;
+};
+export type GetPermissionByIdResponse = Permissions.Permission;
+export type ListPermissionsResponse = {
+    items: Permissions.Permission[];
+};
+export type CreatePermissionPredicateRequest = {
+    permissionId: string;
+    body: Permissions.CreatePermissionPredicateInput;
+};
+export type CreatePermissionPredicateResponse = Permissions.PermissionPredicate;
+export type UpdatePermissionPredicateRequest = {
+    permissionId: string;
+    predicateId: string;
+    body: Permissions.UpdatePermissionPredicateInput;
+};
+export type UpdatePermissionPredicateResponse = Permissions.PermissionPredicate;
+export type ArchivePermissionPredicateRequest = {
+    permissionId: string;
+    predicateId: string;
+    body: Permissions.ArchivePermissionPredicateInput;
+};
+export type ArchivePermissionPredicateResponse = Permissions.PermissionPredicate;
+export type ListPermissionPredicatesRequest = {
+    permissionId: string;
+};
+export type ListPermissionPredicatesResponse = {
+    items: Permissions.PermissionPredicate[];
+};
+export type CreatePermissionAssignmentRequest = {
+    body: Permissions.CreatePermissionAssignmentInput;
+};
+export type CreatePermissionAssignmentResponse = Permissions.PermissionAssignment;
+export type RevokePermissionAssignmentRequest = {
+    assignmentId: string;
+};
+export type RevokePermissionAssignmentResponse = Permissions.DeletionAcknowledgement;
+export type ListPermissionAssignmentsRequest = {
+    query?: {
+        permissionId?: string;
+        identityId?: string;
+    };
+};
+export type ListPermissionAssignmentsResponse = {
+    items: Permissions.PermissionAssignment[];
+};

package/codegen/Permissions/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dfnsApiClient.d.ts

@@ -3,10 +3,11 @@ import { AssetsClient } from './codegen/Assets';
 import { AuthClient } from './codegen/Auth';
 import { BlockchainsClient } from './codegen/Blockchains';
 import { CallbacksClient } from './codegen/Callbacks';
+import { PermissionsClient } from './codegen/Permissions';
 import { PolicyExecutionClient } from './codegen/PolicyExecution';
 import { PolicyManagementClient } from './codegen/PolicyManagement';
 import { PublicKeysClient } from './codegen/PublicKeys';
-import { PermissionsClient } from './generated/permissions';
+import { PermissionsClient as PermissionsV2Client } from './generated/permissions';
 import { PoliciesClient } from './generated/policies';
 import { SignersClient } from './generated/signers';
 import { WalletsClient } from './generated/wallets';
@@ -22,7 +23,11 @@ export declare class DfnsApiClient {
     get auth(): AuthClient;
     get blockchains(): BlockchainsClient;
     get callbacks(): CallbacksClient;
+    /**
+     * @deprecated use permissions v2 instead
+     */
     get permissions(): PermissionsClient;
+    get permissionsV2(): PermissionsV2Client;
     get policies(): PoliciesClient;
     /**
      * @deprecated use the new policy engine instead

package/dfnsApiClient.js

@@ -5,6 +5,7 @@ const Assets_1 = require("./codegen/Assets");
 const Auth_1 = require("./codegen/Auth");
 const Blockchains_1 = require("./codegen/Blockchains");
 const Callbacks_1 = require("./codegen/Callbacks");
+const Permissions_1 = require("./codegen/Permissions");
 const PolicyExecution_1 = require("./codegen/PolicyExecution");
 const PolicyManagement_1 = require("./codegen/PolicyManagement");
 const PublicKeys_1 = require("./codegen/PublicKeys");
@@ -29,7 +30,13 @@ class DfnsApiClient {
     get callbacks() {
         return new Callbacks_1.CallbacksClient(this.apiOptions);
     }
+    /**
+     * @deprecated use permissions v2 instead
+     */
     get permissions() {
+        return new Permissions_1.PermissionsClient(this.apiOptions);
+    }
+    get permissionsV2() {
         return new permissions_1.PermissionsClient(this.apiOptions);
     }
     get policies() {

package/dfnsDelegatedApiClient.d.ts

@@ -3,10 +3,11 @@ import { DelegatedAssetsClient } from './codegen/Assets';
 import { DelegatedAuthClient } from './codegen/Auth';
 import { DelegatedBlockchainsClient } from './codegen/Blockchains';
 import { DelegatedCallbacksClient } from './codegen/Callbacks';
+import { DelegatedPermissionsClient } from './codegen/Permissions';
 import { DelegatedPolicyExecutionClient } from './codegen/PolicyExecution';
 import { DelegatedPolicyManagementClient } from './codegen/PolicyManagement';
 import { DelegatedPublicKeysClient } from './codegen/PublicKeys';
-import { DelegatedPermissionsClient } from './generated/permissions';
+import { DelegatedPermissionsClient as DelegatedPermissionsV2Client } from './generated/permissions';
 import { DelegatedPoliciesClient } from './generated/policies';
 import { DelegatedSignersClient } from './generated/signers';
 import { DelegatedWalletsClient } from './generated/wallets';
@@ -21,7 +22,11 @@ export declare class DfnsDelegatedApiClient {
     get auth(): DelegatedAuthClient;
     get blockchains(): DelegatedBlockchainsClient;
     get callbacks(): DelegatedCallbacksClient;
+    /**
+     * @deprecated use permissions v2 instead
+     */
     get permissions(): DelegatedPermissionsClient;
+    get permissionsV2(): DelegatedPermissionsV2Client;
     get policies(): DelegatedPoliciesClient;
     /**
      * @deprecated use the new policy engine instead

package/dfnsDelegatedApiClient.js

@@ -5,6 +5,7 @@ const Assets_1 = require("./codegen/Assets");
 const Auth_1 = require("./codegen/Auth");
 const Blockchains_1 = require("./codegen/Blockchains");
 const Callbacks_1 = require("./codegen/Callbacks");
+const Permissions_1 = require("./codegen/Permissions");
 const PolicyExecution_1 = require("./codegen/PolicyExecution");
 const PolicyManagement_1 = require("./codegen/PolicyManagement");
 const PublicKeys_1 = require("./codegen/PublicKeys");
@@ -29,7 +30,13 @@ class DfnsDelegatedApiClient {
     get callbacks() {
         return new Callbacks_1.DelegatedCallbacksClient(this.apiOptions);
     }
+    /**
+     * @deprecated use permissions v2 instead
+     */
     get permissions() {
+        return new Permissions_1.DelegatedPermissionsClient(this.apiOptions);
+    }
+    get permissionsV2() {
         return new permissions_1.DelegatedPermissionsClient(this.apiOptions);
     }
     get policies() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dfns/sdk",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "dependencies": {
     "buffer": "6.0.3",
     "cross-fetch": "3.1.6",

package/types/permissions.d.ts

@@ -0,0 +1 @@
+export * from '../generated/permissions/types';

package/types/permissions.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../generated/permissions/types"), exports);