@dfns/sdk 0.0.0-prealpha.9

package/codegen/PolicyExecution/PolicyExecutionClient.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyExecutionClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class PolicyExecutionClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async listPolicyControlExecutions(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-control-executions', {
+            path: {},
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPolicyControlExecutionById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-control-executions/:policyControlExecutionId', {
+            path: { policyControlExecutionId: request.policyControlExecutionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async updatePolicyControlExecution(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-control-executions/:policyControlExecutionId', {
+            path: { policyControlExecutionId: request.policyControlExecutionId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'PUT',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.PolicyExecutionClient = PolicyExecutionClient;

package/codegen/PolicyExecution/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DelegatedPolicyExecutionClient';
+export * from './PolicyExecutionClient';
+export * from './types';

package/codegen/PolicyExecution/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("./DelegatedPolicyExecutionClient"), exports);
+__exportStar(require("./PolicyExecutionClient"), exports);
+__exportStar(require("./types"), exports);

package/codegen/PolicyExecution/types.d.ts

@@ -0,0 +1,18 @@
+import * as PolicyExecution from '../datamodel/PolicyExecution';
+export type ListPolicyControlExecutionsRequest = {
+    query?: {
+        activityId: string;
+    };
+};
+export type ListPolicyControlExecutionsResponse = {
+    items: PolicyExecution.PolicyControlExecution[];
+};
+export type GetPolicyControlExecutionByIdRequest = {
+    policyControlExecutionId: string;
+};
+export type GetPolicyControlExecutionByIdResponse = PolicyExecution.PolicyControlExecution;
+export type UpdatePolicyControlExecutionRequest = {
+    policyControlExecutionId: string;
+    body: PolicyExecution.UpdatePolicyControlExecutionInput;
+};
+export type UpdatePolicyControlExecutionResponse = PolicyExecution.PolicyControlExecution;

package/codegen/PolicyExecution/types.js

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

package/codegen/PolicyManagement/DelegatedPolicyManagementClient.d.ts

@@ -0,0 +1,25 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedPolicyManagementClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    createPolicyInit(request: T.CreatePolicyRequest): Promise<UserActionChallengeResponse>;
+    createPolicyComplete(request: T.CreatePolicyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePolicyResponse>;
+    getPolicyById(request: T.GetPolicyByIdRequest): Promise<T.GetPolicyByIdResponse>;
+    listPolicies(): Promise<T.ListPoliciesResponse>;
+    archivePolicyInit(request: T.ArchivePolicyRequest): Promise<UserActionChallengeResponse>;
+    archivePolicyComplete(request: T.ArchivePolicyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePolicyResponse>;
+    createPolicyControlInit(request: T.CreatePolicyControlRequest): Promise<UserActionChallengeResponse>;
+    createPolicyControlComplete(request: T.CreatePolicyControlRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePolicyControlResponse>;
+    getPolicyControlById(request: T.GetPolicyControlByIdRequest): Promise<T.GetPolicyControlByIdResponse>;
+    listPolicyControls(): Promise<T.ListPolicyControlsResponse>;
+    archivePolicyControlInit(request: T.ArchivePolicyControlRequest): Promise<UserActionChallengeResponse>;
+    archivePolicyControlComplete(request: T.ArchivePolicyControlRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePolicyControlResponse>;
+    createPolicyRuleInit(request: T.CreatePolicyRuleRequest): Promise<UserActionChallengeResponse>;
+    createPolicyRuleComplete(request: T.CreatePolicyRuleRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePolicyRuleResponse>;
+    getPolicyRuleById(request: T.GetPolicyRuleByIdRequest): Promise<T.GetPolicyRuleByIdResponse>;
+    listPolicyRules(request: T.ListPolicyRulesRequest): Promise<T.ListPolicyRulesResponse>;
+    archivePolicyRuleInit(request: T.ArchivePolicyRuleRequest): Promise<UserActionChallengeResponse>;
+    archivePolicyRuleComplete(request: T.ArchivePolicyRuleRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.ArchivePolicyRuleResponse>;
+}

package/codegen/PolicyManagement/DelegatedPolicyManagementClient.js

@@ -0,0 +1,241 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DelegatedPolicyManagementClient = void 0;
+const baseAuthApi_1 = require("../../baseAuthApi");
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class DelegatedPolicyManagementClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createPolicyInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies', {
+            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 createPolicyComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/policies', {
+            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 getPolicyById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
+            path: { policyId: request.policyId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPolicies() {
+        const path = (0, url_1.buildPathAndQuery)('/policies', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePolicyInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
+            path: { policyId: request.policyId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archivePolicyComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
+            path: { policyId: request.policyId },
+            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 createPolicyControlInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls', {
+            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 createPolicyControlComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls', {
+            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 getPolicyControlById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
+            path: { policyControlId: request.policyControlId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPolicyControls() {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePolicyControlInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
+            path: { policyControlId: request.policyControlId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archivePolicyControlComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
+            path: { policyControlId: request.policyControlId },
+            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 createPolicyRuleInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules', {
+            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 createPolicyRuleComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules', {
+            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 getPolicyRuleById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
+            path: { policyRuleId: request.policyRuleId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPolicyRules(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules', {
+            path: {},
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePolicyRuleInit(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
+            path: { policyRuleId: request.policyRuleId },
+            query: {},
+        });
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserActionChallenge({
+            userActionHttpMethod: 'DELETE',
+            userActionHttpPath: path,
+            userActionPayload: JSON.stringify({}),
+            userActionServerKind: 'Api',
+        }, this.apiOptions);
+        return challenge;
+    }
+    async archivePolicyRuleComplete(request, signedChallenge) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
+            path: { policyRuleId: request.policyRuleId },
+            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();
+    }
+}
+exports.DelegatedPolicyManagementClient = DelegatedPolicyManagementClient;

package/codegen/PolicyManagement/PolicyManagementClient.d.ts

@@ -0,0 +1,18 @@
+import { DfnsApiClientOptions } from '../../dfnsApiClient';
+import * as T from './types';
+export declare class PolicyManagementClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    createPolicy(request: T.CreatePolicyRequest): Promise<T.CreatePolicyResponse>;
+    getPolicyById(request: T.GetPolicyByIdRequest): Promise<T.GetPolicyByIdResponse>;
+    listPolicies(): Promise<T.ListPoliciesResponse>;
+    archivePolicy(request: T.ArchivePolicyRequest): Promise<T.ArchivePolicyResponse>;
+    createPolicyControl(request: T.CreatePolicyControlRequest): Promise<T.CreatePolicyControlResponse>;
+    getPolicyControlById(request: T.GetPolicyControlByIdRequest): Promise<T.GetPolicyControlByIdResponse>;
+    listPolicyControls(): Promise<T.ListPolicyControlsResponse>;
+    archivePolicyControl(request: T.ArchivePolicyControlRequest): Promise<T.ArchivePolicyControlResponse>;
+    createPolicyRule(request: T.CreatePolicyRuleRequest): Promise<T.CreatePolicyRuleResponse>;
+    getPolicyRuleById(request: T.GetPolicyRuleByIdRequest): Promise<T.GetPolicyRuleByIdResponse>;
+    listPolicyRules(request: T.ListPolicyRulesRequest): Promise<T.ListPolicyRulesResponse>;
+    archivePolicyRule(request: T.ArchivePolicyRuleRequest): Promise<T.ArchivePolicyRuleResponse>;
+}

package/codegen/PolicyManagement/PolicyManagementClient.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyManagementClient = void 0;
+const fetch_1 = require("../../utils/fetch");
+const url_1 = require("../../utils/url");
+class PolicyManagementClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async createPolicy(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPolicyById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
+            path: { policyId: request.policyId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPolicies() {
+        const path = (0, url_1.buildPathAndQuery)('/policies', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePolicy(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/:policyId', {
+            path: { policyId: request.policyId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createPolicyControl(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPolicyControlById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
+            path: { policyControlId: request.policyControlId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPolicyControls() {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePolicyControl(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-controls/:policyControlId', {
+            path: { policyControlId: request.policyControlId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async createPolicyRule(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules', {
+            path: {},
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'POST',
+            body: request.body,
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async getPolicyRuleById(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
+            path: { policyRuleId: request.policyRuleId },
+            query: {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async listPolicyRules(request) {
+        var _a;
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules', {
+            path: {},
+            query: (_a = request.query) !== null && _a !== void 0 ? _a : {},
+        });
+        const response = await (0, fetch_1.simpleFetch)(path, {
+            method: 'GET',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+    async archivePolicyRule(request) {
+        const path = (0, url_1.buildPathAndQuery)('/policies/policy-rules/:policyRuleId', {
+            path: { policyRuleId: request.policyRuleId },
+            query: {},
+        });
+        const response = await (0, fetch_1.userActionFetch)(path, {
+            method: 'DELETE',
+            apiOptions: this.apiOptions,
+        });
+        return response.json();
+    }
+}
+exports.PolicyManagementClient = PolicyManagementClient;

package/codegen/PolicyManagement/index.d.ts

@@ -0,0 +1,3 @@
+export * from './DelegatedPolicyManagementClient';
+export * from './PolicyManagementClient';
+export * from './types';

package/codegen/PolicyManagement/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("./DelegatedPolicyManagementClient"), exports);
+__exportStar(require("./PolicyManagementClient"), exports);
+__exportStar(require("./types"), exports);

package/codegen/PolicyManagement/types.d.ts

@@ -0,0 +1,51 @@
+import * as PolicyManagement from '../datamodel/PolicyManagement';
+export type CreatePolicyRequest = {
+    body: PolicyManagement.CreatePolicyInput;
+};
+export type CreatePolicyResponse = PolicyManagement.Policy;
+export type GetPolicyByIdRequest = {
+    policyId: string;
+};
+export type GetPolicyByIdResponse = PolicyManagement.Policy;
+export type ListPoliciesResponse = {
+    items: PolicyManagement.Policy[];
+};
+export type ArchivePolicyRequest = {
+    policyId: string;
+};
+export type ArchivePolicyResponse = PolicyManagement.Policy;
+export type CreatePolicyControlRequest = {
+    body: PolicyManagement.CreatePolicyControlInput;
+};
+export type CreatePolicyControlResponse = PolicyManagement.PolicyControl;
+export type GetPolicyControlByIdRequest = {
+    policyControlId: string;
+};
+export type GetPolicyControlByIdResponse = PolicyManagement.PolicyControl;
+export type ListPolicyControlsResponse = {
+    items: PolicyManagement.PolicyControl[];
+};
+export type ArchivePolicyControlRequest = {
+    policyControlId: string;
+};
+export type ArchivePolicyControlResponse = PolicyManagement.PolicyControl;
+export type CreatePolicyRuleRequest = {
+    body: PolicyManagement.CreatePolicyRuleInput;
+};
+export type CreatePolicyRuleResponse = PolicyManagement.PolicyRule;
+export type GetPolicyRuleByIdRequest = {
+    policyRuleId: string;
+};
+export type GetPolicyRuleByIdResponse = PolicyManagement.PolicyRule;
+export type ListPolicyRulesRequest = {
+    query?: {
+        author?: string;
+    };
+};
+export type ListPolicyRulesResponse = {
+    items: PolicyManagement.PolicyRule[];
+};
+export type ArchivePolicyRuleRequest = {
+    policyRuleId: string;
+};
+export type ArchivePolicyRuleResponse = PolicyManagement.PolicyRule;

package/codegen/PolicyManagement/types.js

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

package/codegen/PublicKeys/DelegatedPublicKeysClient.d.ts

@@ -0,0 +1,21 @@
+import { SignUserActionChallengeRequest, UserActionChallengeResponse } from '../../baseAuthApi';
+import { DfnsDelegatedApiClientOptions } from '../../dfnsDelegatedApiClient';
+import * as T from './types';
+export declare class DelegatedPublicKeysClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    getPublicKeyById(request: T.GetPublicKeyByIdRequest): Promise<T.GetPublicKeyByIdResponse>;
+    createPublicKeyInit(request: T.CreatePublicKeyRequest): Promise<UserActionChallengeResponse>;
+    createPublicKeyComplete(request: T.CreatePublicKeyRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreatePublicKeyResponse>;
+    listPublicKeys(): Promise<T.ListPublicKeysResponse>;
+    getAddressForNetwork(request: T.GetAddressForNetworkRequest): Promise<T.GetAddressForNetworkResponse>;
+    getSignatureById(request: T.GetSignatureByIdRequest): Promise<T.GetSignatureByIdResponse>;
+    createSignatureInit(request: T.CreateSignatureRequest): Promise<UserActionChallengeResponse>;
+    createSignatureComplete(request: T.CreateSignatureRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateSignatureResponse>;
+    startWalletConnectSessionInit(request: T.StartWalletConnectSessionRequest): Promise<UserActionChallengeResponse>;
+    startWalletConnectSessionComplete(request: T.StartWalletConnectSessionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.StartWalletConnectSessionResponse>;
+    listTransactions(request: T.ListTransactionsRequest): Promise<T.ListTransactionsResponse>;
+    createTransactionInit(request: T.CreateTransactionRequest): Promise<UserActionChallengeResponse>;
+    createTransactionComplete(request: T.CreateTransactionRequest, signedChallenge: SignUserActionChallengeRequest): Promise<T.CreateTransactionResponse>;
+    getTransactionById(request: T.GetTransactionByIdRequest): Promise<T.GetTransactionByIdResponse>;
+}