@routr/common 2.0.8-alpha.2 → 2.0.8-alpha.20

package/dist/auth.d.ts

@@ -1,10 +1,10 @@
-import { AuthChallengeRequest, AuthChallengeResponse } from "./types";
+import { AuthChallengeRequest, AuthChallengeResponse, ResponseType } from "./types";
 export declare const generateNonce: (algorithm?: string) => string;
 export declare const buildAuthChallenge: (request: AuthChallengeRequest) => {
     realm: string;
-    scheme: string;
-    algorithm: string;
-    qop: string;
+    scheme: "Digest";
+    algorithm: "MD5";
+    qop: import("./types").Qop;
     opaque: string;
     stale: boolean;
     nonce: string;
@@ -13,3 +13,42 @@ export declare const calculateAuthResponse: (res: AuthChallengeResponse, credent
     username: string;
     secret: string;
 }) => string;
+export declare const getCredentials: (username: string, users: {
+    username: string;
+    secret: string;
+}[]) => {
+    username: string;
+    secret: string;
+};
+export declare const createUnauthorizedResponse: (realm: string, params?: {
+    qop: string;
+    algorithm: string;
+}) => {
+    message: {
+        responseType: ResponseType;
+        wwwAuthenticate: {
+            scheme: string;
+            realm: string;
+            qop: string;
+            opaque: string;
+            stale: boolean;
+            nonce: string;
+            algorithm: string;
+        };
+    };
+};
+export declare const createUnauthorizedResponseWithoutChallenge: () => {
+    message: {
+        responseType: ResponseType;
+    };
+};
+export declare const createServerInternalErrorResponse: () => {
+    message: {
+        responseType: ResponseType;
+    };
+};
+export declare const createForbideenResponse: () => {
+    message: {
+        responseType: ResponseType;
+    };
+};

package/dist/auth.js

@@ -3,7 +3,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calculateAuthResponse = exports.buildAuthChallenge = exports.generateNonce = void 0;
+exports.createForbideenResponse = exports.createServerInternalErrorResponse = exports.createUnauthorizedResponseWithoutChallenge = exports.createUnauthorizedResponse = exports.getCredentials = exports.calculateAuthResponse = exports.buildAuthChallenge = exports.generateNonce = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const types_1 = require("./types");
 const crypto_1 = __importDefault(require("crypto"));
 const DEFAULT_ALGORITHM = "MD5";
 const md5hex = (str, algorithm = DEFAULT_ALGORITHM) => crypto_1.default.createHash(algorithm).update(str).digest("hex");
@@ -35,3 +54,46 @@ const calculateAuthResponse = (res, credentials) => {
         : md5hex(`${ha1}:${res.nonce}:${ha2}`);
 };
 exports.calculateAuthResponse = calculateAuthResponse;
+const getCredentials = (username, users) => users.find((user) => user.username === username);
+exports.getCredentials = getCredentials;
+const createUnauthorizedResponse = (realm, params = { qop: "auth", algorithm: DEFAULT_ALGORITHM }) => {
+    return {
+        message: {
+            responseType: types_1.ResponseType.UNAUTHORIZED,
+            wwwAuthenticate: {
+                scheme: "Digest",
+                realm: realm,
+                qop: params.qop,
+                opaque: "",
+                stale: false,
+                nonce: (0, exports.generateNonce)(),
+                algorithm: params.algorithm
+            }
+        }
+    };
+};
+exports.createUnauthorizedResponse = createUnauthorizedResponse;
+const createUnauthorizedResponseWithoutChallenge = () => {
+    return {
+        message: {
+            responseType: types_1.ResponseType.UNAUTHORIZED
+        }
+    };
+};
+exports.createUnauthorizedResponseWithoutChallenge = createUnauthorizedResponseWithoutChallenge;
+const createServerInternalErrorResponse = () => {
+    return {
+        message: {
+            responseType: types_1.ResponseType.SERVER_INTERNAL_ERROR
+        }
+    };
+};
+exports.createServerInternalErrorResponse = createServerInternalErrorResponse;
+const createForbideenResponse = () => {
+    return {
+        message: {
+            responseType: types_1.ResponseType.FORBIDDEN
+        }
+    };
+};
+exports.createForbideenResponse = createForbideenResponse;

package/dist/connect/api/client.d.ts

@@ -0,0 +1,3 @@
+import { APIClient, DataAPIOptions, ServiceAPI, ServiceAPIOptions } from "./types";
+export declare function apiClient(options: DataAPIOptions): APIClient;
+export declare function serviceAPI<R>(options: ServiceAPIOptions): ServiceAPI<R>;

package/dist/connect/api/client.js

@@ -0,0 +1,158 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serviceAPI = exports.apiClient = void 0;
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster/routr
+ *
+ * This file is part of Routr
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* eslint-disable require-jsdoc */
+const grpc = __importStar(require("@grpc/grpc-js"));
+const pb_util_1 = require("pb-util");
+const errors_1 = require("../../errors");
+const client_1 = require("../client");
+const types_1 = require("../types");
+function fire(err, apiAddr) {
+    if (err.code === grpc.status.UNAVAILABLE) {
+        return new errors_1.ServiceUnavailableError(`api server at ${apiAddr} is unavailable`);
+    }
+    return err;
+}
+function apiClient(options) {
+    return {
+        agents: serviceAPI(Object.assign({ kind: types_1.Kind.AGENT }, options)),
+        domains: serviceAPI(Object.assign({ kind: types_1.Kind.DOMAIN }, options)),
+        trunks: serviceAPI(Object.assign({ kind: types_1.Kind.TRUNK }, options)),
+        credentials: serviceAPI(Object.assign({ kind: types_1.Kind.CREDENTIALS }, options)),
+        acl: serviceAPI(Object.assign({ kind: types_1.Kind.ACL }, options)),
+        peers: serviceAPI(Object.assign({ kind: types_1.Kind.PEER }, options)),
+        numbers: serviceAPI(Object.assign({ kind: types_1.Kind.NUMBER }, options))
+    };
+}
+exports.apiClient = apiClient;
+function serviceAPI(options) {
+    const { kind, apiAddr, credentials, metadata } = options;
+    // Workaround for issue not allowing to pass metadata to grpc-js
+    const meta = new grpc.Metadata();
+    if (metadata) {
+        Object.keys(metadata.toJSON()).forEach((key) => {
+            meta.set(key, metadata.getMap()[key]);
+        });
+    }
+    const client = (0, client_1.createConnectClient)({
+        kind,
+        apiAddr,
+        credentials: credentials !== null && credentials !== void 0 ? credentials : grpc.credentials.createInsecure()
+    });
+    return {
+        create: (request) => new Promise((resolve, reject) => {
+            if (request.extended) {
+                request.extended = pb_util_1.struct.encode(request.extended);
+            }
+            client.create(request, meta, (err, response) => {
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                if (response.extended) {
+                    response.extended = pb_util_1.struct.decode(response.extended);
+                }
+                resolve(response);
+            });
+        }),
+        update: (request) => new Promise((resolve, reject) => {
+            if (request.extended) {
+                request.extended = pb_util_1.struct.encode(request.extended);
+            }
+            client.update(request, meta, (err, response) => {
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                if (response.extended) {
+                    response.extended = pb_util_1.struct.decode(response.extended);
+                }
+                resolve(response);
+            });
+        }),
+        get: (ref) => new Promise((resolve, reject) => {
+            client.get({ ref }, meta, (err, response) => {
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                if (response.extended) {
+                    response.extended = pb_util_1.struct.decode(response.extended);
+                }
+                resolve(response);
+            });
+        }),
+        list: (request) => new Promise((resolve, reject) => {
+            client.list(request, meta, (err, response) => {
+                var _a;
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                response.items.forEach((item) => {
+                    if (item.extended) {
+                        item.extended = pb_util_1.struct.decode(item.extended);
+                    }
+                });
+                resolve({
+                    items: (_a = response === null || response === void 0 ? void 0 : response.items) !== null && _a !== void 0 ? _a : [],
+                    nextPageToken: response.nextPageToken
+                });
+            });
+        }),
+        findBy: (request) => new Promise((resolve, reject) => {
+            client.findBy(request, meta, (err, response) => {
+                if (err) {
+                    return reject(fire(err, apiAddr));
+                }
+                response.items.forEach((item) => {
+                    if (item.extended) {
+                        item.extended = pb_util_1.struct.decode(item.extended);
+                    }
+                });
+                resolve(response);
+            });
+        }),
+        del: (ref) => new Promise((resolve, reject) => {
+            client.get({ ref }, meta, (err) => err ? reject(fire(err, apiAddr)) : resolve());
+        })
+    };
+}
+exports.serviceAPI = serviceAPI;

package/dist/connect/api/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./client";
+export * from "./types";

package/dist/connect/api/index.js

@@ -0,0 +1,36 @@
+"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 });
+/*
+ * Copyright (C) 2023 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster
+ *
+ * This file is part of Routr.
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+__exportStar(require("./client"), exports);
+__exportStar(require("./types"), exports);

package/dist/connect/api/types.d.ts

@@ -0,0 +1,51 @@
+import * as grpc from "@grpc/grpc-js";
+import { JsonObject } from "pb-util/build";
+import { AccessControlList, Agent, Credentials, Domain, INumber, Kind, Peer, Trunk } from "../types";
+export interface DataAPIOptions {
+    apiAddr: string;
+    credentials?: grpc.ChannelCredentials;
+    metadata?: grpc.Metadata;
+}
+export interface ServiceAPIOptions {
+    apiAddr: string;
+    kind: Kind;
+    credentials?: grpc.ChannelCredentials;
+    metadata?: grpc.Metadata;
+}
+export interface FindByRequest {
+    fieldName: string;
+    fieldValue: string | boolean | number;
+}
+export interface ListRequest {
+    pageSize: number;
+    pageToken: string;
+}
+export interface ListResponse<R> {
+    items: R[];
+    nextPageToken: string;
+}
+export interface FindByResponse<R> {
+    items: R[];
+}
+export type APIClient = {
+    agents: ServiceAPI<Agent>;
+    domains: ServiceAPI<Domain>;
+    trunks: ServiceAPI<Trunk>;
+    credentials: ServiceAPI<Credentials>;
+    acl: ServiceAPI<AccessControlList>;
+    peers: ServiceAPI<Peer>;
+    numbers: ServiceAPI<INumber>;
+};
+export type ServiceAPI<R extends {
+    extended?: JsonObject;
+}> = {
+    create: (request: unknown) => Promise<R>;
+    update: (request: unknown) => Promise<R>;
+    get: (ref: string) => Promise<R>;
+    del: (ref: string) => Promise<void>;
+    list: (request: {
+        pageSize: number;
+        pageToken: string;
+    }) => Promise<ListResponse<R>>;
+    findBy: (request: FindByRequest) => Promise<FindByResponse<R>>;
+};

package/dist/connect/api/types.js

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

package/dist/connect/client.d.ts

@@ -0,0 +1,8 @@
+import * as grpc from "@grpc/grpc-js";
+import { Kind, KindWithoutUnknown } from "./types";
+export declare function createConnectClient(options: {
+    kind: Kind;
+    credentials: grpc.ChannelCredentials;
+    apiAddr: string;
+}): any;
+export declare function createConnectService(kind: KindWithoutUnknown): any;

package/dist/connect/{grpc_client.js → client.js}

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESOURCES_PROTO = void 0;
+exports.createConnectService = exports.createConnectClient = void 0;
 /*
  * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
  * http://github.com/fonoster/routr
@@ -42,15 +42,53 @@ exports.RESOURCES_PROTO = void 0;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/* eslint-disable require-jsdoc */
 const grpc = __importStar(require("@grpc/grpc-js"));
 const protoLoader = require("@grpc/proto-loader");
-const packageDefinition = protoLoader.loadSync(__dirname + "/../protos/resources.proto", {
+const helper_1 = require("../helper");
+const types_1 = require("./types");
+const protoOptions = {
     keepCase: false,
     longs: String,
     enums: String,
     defaults: true,
     oneofs: true
-});
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
-exports.RESOURCES_PROTO = protoDescriptor.fonoster.routr.resources;
+};
+function getProtoPath(kind) {
+    switch (kind) {
+        case types_1.Kind.ACL:
+            return __dirname + "/protos/acl.proto";
+        case types_1.Kind.CREDENTIALS:
+            return __dirname + "/protos/credentials.proto";
+        default:
+            return __dirname + `/protos/${kind}s.proto`;
+    }
+}
+function createConnectClient(options) {
+    const def = protoLoader.loadSync(getProtoPath(options.kind), protoOptions);
+    const descriptor = grpc.loadPackageDefinition(def);
+    const base = descriptor.fonoster.routr.connect;
+    switch (options.kind) {
+        case types_1.Kind.ACL:
+            return new base.acl.v2draft1.ACLService(options.apiAddr, options.credentials);
+        case types_1.Kind.CREDENTIALS:
+            return new base.credentials.v2draft1.CredentialsService(options.apiAddr, options.credentials);
+        default:
+            return new base[options.kind + "s"].v2draft1[(0, helper_1.toPascaleCase)(options.kind) + "s"](options.apiAddr, options.credentials);
+    }
+}
+exports.createConnectClient = createConnectClient;
+function createConnectService(kind) {
+    const def = protoLoader.loadSync(getProtoPath(kind), protoOptions);
+    const descriptor = grpc.loadPackageDefinition(def);
+    const base = descriptor.fonoster.routr.connect;
+    switch (kind) {
+        case types_1.Kind.ACL:
+            return base.acl.v2draft1.ACLService.service;
+        case types_1.Kind.CREDENTIALS:
+            return base.credentials.v2draft1.CredentialsService.service;
+        default:
+            return base[kind + "s"].v2draft1[(0, helper_1.toPascaleCase)(kind) + "s"].service;
+    }
+}
+exports.createConnectService = createConnectService;

package/dist/connect/config.d.ts

@@ -0,0 +1,113 @@
+import { LoadBalancingAlgorithm, Privacy, Transport } from "../types";
+import { Kind } from "./types";
+export interface ConfigBase {
+    apiVersion: string;
+    ref: string;
+    metadata: {
+        name: string;
+    };
+}
+export interface AccessControlListConfig extends ConfigBase {
+    kind: Kind.ACL;
+    spec: {
+        accessControlList: {
+            allow: string[];
+            deny: string[];
+        };
+    };
+}
+export interface AgentConfig extends ConfigBase {
+    kind: Kind.AGENT;
+    spec: {
+        username: string;
+        domainRef: string;
+        credentialsRef: string;
+        privacy: Privacy;
+        enabled: boolean;
+    };
+}
+export interface PeerConfig extends ConfigBase {
+    kind: Kind.PEER;
+    spec: {
+        aor: string;
+        username: string;
+        credentialsRef?: string;
+        contactAddr?: string;
+        enabled?: boolean;
+        loadBalancing?: {
+            algorithm: LoadBalancingAlgorithm;
+            withSessionAffinity: boolean;
+        };
+    };
+}
+export interface CredentialsConfig extends ConfigBase {
+    kind: Kind.CREDENTIALS;
+    spec: {
+        credentials: {
+            username: string;
+            password: string;
+        };
+    };
+}
+export interface DomainConfig extends ConfigBase {
+    kind: Kind.DOMAIN;
+    spec: {
+        accessControlListRef?: string;
+        context: {
+            domainUri: string;
+            egressPolicies?: {
+                rule: string;
+                numberRef: string;
+            }[];
+        };
+    };
+}
+export interface NumberConfig extends Omit<ConfigBase, "metadata"> {
+    kind: Kind.NUMBER;
+    metadata: {
+        name: string;
+        geoInfo: {
+            city: string;
+            country: string;
+            countryISOCode: string;
+        };
+    };
+    spec: {
+        trunkRef: string;
+        location: {
+            telUrl: string;
+            aorLink: string;
+            sessionAffinityHeader: string;
+            extraHeaders: {
+                name: string;
+                value: string;
+            }[];
+        };
+    };
+}
+export interface TrunkConfig extends ConfigBase {
+    kind: Kind.TRUNK;
+    spec: {
+        inbound: {
+            uri: string;
+            accessControlListRef: string;
+            credentialsRef: string;
+        };
+        outbound: {
+            sendRegister: boolean;
+            credentialsRef: string;
+            uris: {
+                uri: {
+                    user: string;
+                    host: string;
+                    port: number;
+                    transport: Transport;
+                };
+                priority: number;
+                weight: number;
+                enabled: boolean;
+            }[];
+        };
+    };
+}
+export type UserConfig = AccessControlListConfig | AgentConfig | PeerConfig | CredentialsConfig | DomainConfig | NumberConfig | TrunkConfig;

package/dist/connect/config.js

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

package/dist/connect/connect_error.d.ts

@@ -0,0 +1,21 @@
+import { HeaderModifier, ResponseType } from "../types";
+export declare const CodeToResponseTypeMap: {
+    401: ResponseType;
+    403: ResponseType;
+    500: ResponseType;
+};
+export interface ConnectError {
+    code: keyof typeof CodeToResponseTypeMap;
+    reason?: string;
+    headers: HeaderModifier[];
+}
+export declare const convertToErrorResponse: (connectError: ConnectError) => {
+    message: {
+        responseType: ResponseType;
+        reasonPhrase: string;
+        extensions: {
+            name: string;
+            value: string;
+        }[];
+    };
+};

package/dist/connect/connect_error.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToErrorResponse = exports.CodeToResponseTypeMap = void 0;
+const types_1 = require("../types");
+/*
+ * Copyright (C) 2022 by Fonoster Inc (https://fonoster.com)
+ * http://github.com/fonoster
+ *
+ * This file is part of Routr.
+ *
+ * Licensed under the MIT License (the "License");
+ * you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ *    https://opensource.org/licenses/MIT
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+exports.CodeToResponseTypeMap = {
+    401: types_1.ResponseType.UNAUTHORIZED,
+    403: types_1.ResponseType.FORBIDDEN,
+    500: types_1.ResponseType.SERVER_ERROR
+};
+const convertToErrorResponse = (connectError) => {
+    return {
+        message: {
+            responseType: exports.CodeToResponseTypeMap[connectError.code],
+            reasonPhrase: connectError.reason,
+            extensions: connectError.headers.map((modifier) => {
+                if (modifier.action === types_1.HeaderModifierAction.ADD) {
+                    return {
+                        name: modifier.name,
+                        value: modifier.value
+                    };
+                }
+            })
+        }
+    };
+};
+exports.convertToErrorResponse = convertToErrorResponse;

package/dist/connect/index.d.ts

@@ -1,3 +1,5 @@
-export * from "./data_api";
-export * from "./grpc_client";
+export * from "./api";
+export * from "./client";
 export * from "./types";
+export * from "./config";
+export * from "./mappers";

package/dist/connect/index.js

@@ -32,6 +32,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-__exportStar(require("./data_api"), exports);
-__exportStar(require("./grpc_client"), exports);
+__exportStar(require("./api"), exports);
+__exportStar(require("./client"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./config"), exports);
+__exportStar(require("./mappers"), exports);

package/dist/connect/mappers/acl.d.ts

@@ -0,0 +1,3 @@
+import { AccessControlListConfig } from "../config";
+import { AccessControlList } from "../types";
+export declare function mapToACL(config: AccessControlListConfig): AccessControlList;