@0xkaleab/sdk-js 0.2.7

package/dist/esm/codegen/google/iam/v1/policy.js

@@ -0,0 +1,1032 @@
+// @ts-nocheck
+/* eslint-disable */
+import { Expr } from "../../type/expr";
+import { BinaryReader, BinaryWriter } from "../../../binary";
+import { bytesFromBase64, base64FromBytes, isSet } from "../../../helpers";
+import { GlobalDecoderRegistry } from "../../../registry";
+/**
+ * The list of valid permission types for which logging can be configured.
+ * Admin writes are always logged, and are not configurable.
+ */
+export var AuditLogConfig_LogType;
+(function (AuditLogConfig_LogType) {
+    /** LOG_TYPE_UNSPECIFIED - Default case. Should never be this. */
+    AuditLogConfig_LogType[AuditLogConfig_LogType["LOG_TYPE_UNSPECIFIED"] = 0] = "LOG_TYPE_UNSPECIFIED";
+    /** ADMIN_READ - Admin reads. Example: CloudIAM getIamPolicy */
+    AuditLogConfig_LogType[AuditLogConfig_LogType["ADMIN_READ"] = 1] = "ADMIN_READ";
+    /** DATA_WRITE - Data writes. Example: CloudSQL Users create */
+    AuditLogConfig_LogType[AuditLogConfig_LogType["DATA_WRITE"] = 2] = "DATA_WRITE";
+    /** DATA_READ - Data reads. Example: CloudSQL Users list */
+    AuditLogConfig_LogType[AuditLogConfig_LogType["DATA_READ"] = 3] = "DATA_READ";
+    AuditLogConfig_LogType[AuditLogConfig_LogType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(AuditLogConfig_LogType || (AuditLogConfig_LogType = {}));
+export const AuditLogConfig_LogTypeAmino = AuditLogConfig_LogType;
+export function auditLogConfig_LogTypeFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "LOG_TYPE_UNSPECIFIED":
+            return AuditLogConfig_LogType.LOG_TYPE_UNSPECIFIED;
+        case 1:
+        case "ADMIN_READ":
+            return AuditLogConfig_LogType.ADMIN_READ;
+        case 2:
+        case "DATA_WRITE":
+            return AuditLogConfig_LogType.DATA_WRITE;
+        case 3:
+        case "DATA_READ":
+            return AuditLogConfig_LogType.DATA_READ;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return AuditLogConfig_LogType.UNRECOGNIZED;
+    }
+}
+export function auditLogConfig_LogTypeToJSON(object) {
+    switch (object) {
+        case AuditLogConfig_LogType.LOG_TYPE_UNSPECIFIED:
+            return "LOG_TYPE_UNSPECIFIED";
+        case AuditLogConfig_LogType.ADMIN_READ:
+            return "ADMIN_READ";
+        case AuditLogConfig_LogType.DATA_WRITE:
+            return "DATA_WRITE";
+        case AuditLogConfig_LogType.DATA_READ:
+            return "DATA_READ";
+        case AuditLogConfig_LogType.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** The type of action performed on a Binding in a policy. */
+export var BindingDelta_Action;
+(function (BindingDelta_Action) {
+    /** ACTION_UNSPECIFIED - Unspecified. */
+    BindingDelta_Action[BindingDelta_Action["ACTION_UNSPECIFIED"] = 0] = "ACTION_UNSPECIFIED";
+    /** ADD - Addition of a Binding. */
+    BindingDelta_Action[BindingDelta_Action["ADD"] = 1] = "ADD";
+    /** REMOVE - Removal of a Binding. */
+    BindingDelta_Action[BindingDelta_Action["REMOVE"] = 2] = "REMOVE";
+    BindingDelta_Action[BindingDelta_Action["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(BindingDelta_Action || (BindingDelta_Action = {}));
+export const BindingDelta_ActionAmino = BindingDelta_Action;
+export function bindingDelta_ActionFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "ACTION_UNSPECIFIED":
+            return BindingDelta_Action.ACTION_UNSPECIFIED;
+        case 1:
+        case "ADD":
+            return BindingDelta_Action.ADD;
+        case 2:
+        case "REMOVE":
+            return BindingDelta_Action.REMOVE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return BindingDelta_Action.UNRECOGNIZED;
+    }
+}
+export function bindingDelta_ActionToJSON(object) {
+    switch (object) {
+        case BindingDelta_Action.ACTION_UNSPECIFIED:
+            return "ACTION_UNSPECIFIED";
+        case BindingDelta_Action.ADD:
+            return "ADD";
+        case BindingDelta_Action.REMOVE:
+            return "REMOVE";
+        case BindingDelta_Action.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+/** The type of action performed on an audit configuration in a policy. */
+export var AuditConfigDelta_Action;
+(function (AuditConfigDelta_Action) {
+    /** ACTION_UNSPECIFIED - Unspecified. */
+    AuditConfigDelta_Action[AuditConfigDelta_Action["ACTION_UNSPECIFIED"] = 0] = "ACTION_UNSPECIFIED";
+    /** ADD - Addition of an audit configuration. */
+    AuditConfigDelta_Action[AuditConfigDelta_Action["ADD"] = 1] = "ADD";
+    /** REMOVE - Removal of an audit configuration. */
+    AuditConfigDelta_Action[AuditConfigDelta_Action["REMOVE"] = 2] = "REMOVE";
+    AuditConfigDelta_Action[AuditConfigDelta_Action["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(AuditConfigDelta_Action || (AuditConfigDelta_Action = {}));
+export const AuditConfigDelta_ActionAmino = AuditConfigDelta_Action;
+export function auditConfigDelta_ActionFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "ACTION_UNSPECIFIED":
+            return AuditConfigDelta_Action.ACTION_UNSPECIFIED;
+        case 1:
+        case "ADD":
+            return AuditConfigDelta_Action.ADD;
+        case 2:
+        case "REMOVE":
+            return AuditConfigDelta_Action.REMOVE;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return AuditConfigDelta_Action.UNRECOGNIZED;
+    }
+}
+export function auditConfigDelta_ActionToJSON(object) {
+    switch (object) {
+        case AuditConfigDelta_Action.ACTION_UNSPECIFIED:
+            return "ACTION_UNSPECIFIED";
+        case AuditConfigDelta_Action.ADD:
+            return "ADD";
+        case AuditConfigDelta_Action.REMOVE:
+            return "REMOVE";
+        case AuditConfigDelta_Action.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBasePolicy() {
+    return {
+        version: 0,
+        bindings: [],
+        auditConfigs: [],
+        etag: new Uint8Array()
+    };
+}
+/**
+ * An Identity and Access Management (IAM) policy, which specifies access
+ * controls for Google Cloud resources.
+ *
+ *
+ * A `Policy` is a collection of `bindings`. A `binding` binds one or more
+ * `members`, or principals, to a single `role`. Principals can be user
+ * accounts, service accounts, Google groups, and domains (such as G Suite). A
+ * `role` is a named list of permissions; each `role` can be an IAM predefined
+ * role or a user-created custom role.
+ *
+ * For some types of Google Cloud resources, a `binding` can also specify a
+ * `condition`, which is a logical expression that allows access to a resource
+ * only if the expression evaluates to `true`. A condition can add constraints
+ * based on attributes of the request, the resource, or both. To learn which
+ * resources support conditions in their IAM policies, see the
+ * [IAM
+ * documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
+ *
+ * **JSON example:**
+ *
+ * ```
+ *     {
+ *       "bindings": [
+ *         {
+ *           "role": "roles/resourcemanager.organizationAdmin",
+ *           "members": [
+ *             "user:mike@example.com",
+ *             "group:admins@example.com",
+ *             "domain:google.com",
+ *             "serviceAccount:my-project-id@appspot.gserviceaccount.com"
+ *           ]
+ *         },
+ *         {
+ *           "role": "roles/resourcemanager.organizationViewer",
+ *           "members": [
+ *             "user:eve@example.com"
+ *           ],
+ *           "condition": {
+ *             "title": "expirable access",
+ *             "description": "Does not grant access after Sep 2020",
+ *             "expression": "request.time <
+ *             timestamp('2020-10-01T00:00:00.000Z')",
+ *           }
+ *         }
+ *       ],
+ *       "etag": "BwWWja0YfJA=",
+ *       "version": 3
+ *     }
+ * ```
+ *
+ * **YAML example:**
+ *
+ * ```
+ *     bindings:
+ *     - members:
+ *       - user:mike@example.com
+ *       - group:admins@example.com
+ *       - domain:google.com
+ *       - serviceAccount:my-project-id@appspot.gserviceaccount.com
+ *       role: roles/resourcemanager.organizationAdmin
+ *     - members:
+ *       - user:eve@example.com
+ *       role: roles/resourcemanager.organizationViewer
+ *       condition:
+ *         title: expirable access
+ *         description: Does not grant access after Sep 2020
+ *         expression: request.time < timestamp('2020-10-01T00:00:00.000Z')
+ *     etag: BwWWja0YfJA=
+ *     version: 3
+ * ```
+ *
+ * For a description of IAM and its features, see the
+ * [IAM documentation](https://cloud.google.com/iam/docs/).
+ * @name Policy
+ * @package google.iam.v1
+ * @see proto type: google.iam.v1.Policy
+ */
+export const Policy = {
+    typeUrl: "/google.iam.v1.Policy",
+    is(o) {
+        return o && (o.$typeUrl === Policy.typeUrl || typeof o.version === "number" && Array.isArray(o.bindings) && (!o.bindings.length || Binding.is(o.bindings[0])) && Array.isArray(o.auditConfigs) && (!o.auditConfigs.length || AuditConfig.is(o.auditConfigs[0])) && (o.etag instanceof Uint8Array || typeof o.etag === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Policy.typeUrl || typeof o.version === "number" && Array.isArray(o.bindings) && (!o.bindings.length || Binding.isAmino(o.bindings[0])) && Array.isArray(o.audit_configs) && (!o.audit_configs.length || AuditConfig.isAmino(o.audit_configs[0])) && (o.etag instanceof Uint8Array || typeof o.etag === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.version !== 0) {
+            writer.uint32(8).int32(message.version);
+        }
+        for (const v of message.bindings) {
+            Binding.encode(v, writer.uint32(34).fork()).ldelim();
+        }
+        for (const v of message.auditConfigs) {
+            AuditConfig.encode(v, writer.uint32(50).fork()).ldelim();
+        }
+        if (message.etag.length !== 0) {
+            writer.uint32(26).bytes(message.etag);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePolicy();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.version = reader.int32();
+                    break;
+                case 4:
+                    message.bindings.push(Binding.decode(reader, reader.uint32()));
+                    break;
+                case 6:
+                    message.auditConfigs.push(AuditConfig.decode(reader, reader.uint32()));
+                    break;
+                case 3:
+                    message.etag = reader.bytes();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePolicy();
+        message.version = object.version ?? 0;
+        message.bindings = object.bindings?.map(e => Binding.fromPartial(e)) || [];
+        message.auditConfigs = object.auditConfigs?.map(e => AuditConfig.fromPartial(e)) || [];
+        message.etag = object.etag ?? new Uint8Array();
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePolicy();
+        if (object.version !== undefined && object.version !== null) {
+            message.version = object.version;
+        }
+        message.bindings = object.bindings?.map(e => Binding.fromAmino(e)) || [];
+        message.auditConfigs = object.audit_configs?.map(e => AuditConfig.fromAmino(e)) || [];
+        if (object.etag !== undefined && object.etag !== null) {
+            message.etag = bytesFromBase64(object.etag);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.version = message.version === 0 ? undefined : message.version;
+        if (message.bindings) {
+            obj.bindings = message.bindings.map(e => e ? Binding.toAmino(e) : undefined);
+        }
+        else {
+            obj.bindings = message.bindings;
+        }
+        if (message.auditConfigs) {
+            obj.audit_configs = message.auditConfigs.map(e => e ? AuditConfig.toAmino(e) : undefined);
+        }
+        else {
+            obj.audit_configs = message.auditConfigs;
+        }
+        obj.etag = message.etag ? base64FromBytes(message.etag) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Policy.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Policy.decode(message.value);
+    },
+    toProto(message) {
+        return Policy.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.iam.v1.Policy",
+            value: Policy.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Policy.typeUrl)) {
+            return;
+        }
+        Binding.registerTypeUrl();
+        AuditConfig.registerTypeUrl();
+    }
+};
+function createBaseBinding() {
+    return {
+        role: "",
+        members: [],
+        condition: undefined
+    };
+}
+/**
+ * Associates `members`, or principals, with a `role`.
+ * @name Binding
+ * @package google.iam.v1
+ * @see proto type: google.iam.v1.Binding
+ */
+export const Binding = {
+    typeUrl: "/google.iam.v1.Binding",
+    is(o) {
+        return o && (o.$typeUrl === Binding.typeUrl || typeof o.role === "string" && Array.isArray(o.members) && (!o.members.length || typeof o.members[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === Binding.typeUrl || typeof o.role === "string" && Array.isArray(o.members) && (!o.members.length || typeof o.members[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.role !== "") {
+            writer.uint32(10).string(message.role);
+        }
+        for (const v of message.members) {
+            writer.uint32(18).string(v);
+        }
+        if (message.condition !== undefined) {
+            Expr.encode(message.condition, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBinding();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.role = reader.string();
+                    break;
+                case 2:
+                    message.members.push(reader.string());
+                    break;
+                case 3:
+                    message.condition = Expr.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBinding();
+        message.role = object.role ?? "";
+        message.members = object.members?.map(e => e) || [];
+        message.condition = object.condition !== undefined && object.condition !== null ? Expr.fromPartial(object.condition) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBinding();
+        if (object.role !== undefined && object.role !== null) {
+            message.role = object.role;
+        }
+        message.members = object.members?.map(e => e) || [];
+        if (object.condition !== undefined && object.condition !== null) {
+            message.condition = Expr.fromAmino(object.condition);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.role = message.role === "" ? undefined : message.role;
+        if (message.members) {
+            obj.members = message.members.map(e => e);
+        }
+        else {
+            obj.members = message.members;
+        }
+        obj.condition = message.condition ? Expr.toAmino(message.condition) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return Binding.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return Binding.decode(message.value);
+    },
+    toProto(message) {
+        return Binding.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.iam.v1.Binding",
+            value: Binding.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(Binding.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseAuditConfig() {
+    return {
+        service: "",
+        auditLogConfigs: []
+    };
+}
+/**
+ * Specifies the audit configuration for a service.
+ * The configuration determines which permission types are logged, and what
+ * identities, if any, are exempted from logging.
+ * An AuditConfig must have one or more AuditLogConfigs.
+ *
+ * If there are AuditConfigs for both `allServices` and a specific service,
+ * the union of the two AuditConfigs is used for that service: the log_types
+ * specified in each AuditConfig are enabled, and the exempted_members in each
+ * AuditLogConfig are exempted.
+ *
+ * Example Policy with multiple AuditConfigs:
+ *
+ *     {
+ *       "audit_configs": [
+ *         {
+ *           "service": "allServices",
+ *           "audit_log_configs": [
+ *             {
+ *               "log_type": "DATA_READ",
+ *               "exempted_members": [
+ *                 "user:jose@example.com"
+ *               ]
+ *             },
+ *             {
+ *               "log_type": "DATA_WRITE"
+ *             },
+ *             {
+ *               "log_type": "ADMIN_READ"
+ *             }
+ *           ]
+ *         },
+ *         {
+ *           "service": "sampleservice.googleapis.com",
+ *           "audit_log_configs": [
+ *             {
+ *               "log_type": "DATA_READ"
+ *             },
+ *             {
+ *               "log_type": "DATA_WRITE",
+ *               "exempted_members": [
+ *                 "user:aliya@example.com"
+ *               ]
+ *             }
+ *           ]
+ *         }
+ *       ]
+ *     }
+ *
+ * For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ
+ * logging. It also exempts `jose@example.com` from DATA_READ logging, and
+ * `aliya@example.com` from DATA_WRITE logging.
+ * @name AuditConfig
+ * @package google.iam.v1
+ * @see proto type: google.iam.v1.AuditConfig
+ */
+export const AuditConfig = {
+    typeUrl: "/google.iam.v1.AuditConfig",
+    is(o) {
+        return o && (o.$typeUrl === AuditConfig.typeUrl || typeof o.service === "string" && Array.isArray(o.auditLogConfigs) && (!o.auditLogConfigs.length || AuditLogConfig.is(o.auditLogConfigs[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === AuditConfig.typeUrl || typeof o.service === "string" && Array.isArray(o.audit_log_configs) && (!o.audit_log_configs.length || AuditLogConfig.isAmino(o.audit_log_configs[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.service !== "") {
+            writer.uint32(10).string(message.service);
+        }
+        for (const v of message.auditLogConfigs) {
+            AuditLogConfig.encode(v, writer.uint32(26).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAuditConfig();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.service = reader.string();
+                    break;
+                case 3:
+                    message.auditLogConfigs.push(AuditLogConfig.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAuditConfig();
+        message.service = object.service ?? "";
+        message.auditLogConfigs = object.auditLogConfigs?.map(e => AuditLogConfig.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAuditConfig();
+        if (object.service !== undefined && object.service !== null) {
+            message.service = object.service;
+        }
+        message.auditLogConfigs = object.audit_log_configs?.map(e => AuditLogConfig.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.service = message.service === "" ? undefined : message.service;
+        if (message.auditLogConfigs) {
+            obj.audit_log_configs = message.auditLogConfigs.map(e => e ? AuditLogConfig.toAmino(e) : undefined);
+        }
+        else {
+            obj.audit_log_configs = message.auditLogConfigs;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return AuditConfig.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return AuditConfig.decode(message.value);
+    },
+    toProto(message) {
+        return AuditConfig.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.iam.v1.AuditConfig",
+            value: AuditConfig.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(AuditConfig.typeUrl)) {
+            return;
+        }
+        AuditLogConfig.registerTypeUrl();
+    }
+};
+function createBaseAuditLogConfig() {
+    return {
+        logType: 0,
+        exemptedMembers: []
+    };
+}
+/**
+ * Provides the configuration for logging a type of permissions.
+ * Example:
+ *
+ *     {
+ *       "audit_log_configs": [
+ *         {
+ *           "log_type": "DATA_READ",
+ *           "exempted_members": [
+ *             "user:jose@example.com"
+ *           ]
+ *         },
+ *         {
+ *           "log_type": "DATA_WRITE"
+ *         }
+ *       ]
+ *     }
+ *
+ * This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting
+ * jose@example.com from DATA_READ logging.
+ * @name AuditLogConfig
+ * @package google.iam.v1
+ * @see proto type: google.iam.v1.AuditLogConfig
+ */
+export const AuditLogConfig = {
+    typeUrl: "/google.iam.v1.AuditLogConfig",
+    is(o) {
+        return o && (o.$typeUrl === AuditLogConfig.typeUrl || isSet(o.logType) && Array.isArray(o.exemptedMembers) && (!o.exemptedMembers.length || typeof o.exemptedMembers[0] === "string"));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === AuditLogConfig.typeUrl || isSet(o.log_type) && Array.isArray(o.exempted_members) && (!o.exempted_members.length || typeof o.exempted_members[0] === "string"));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.logType !== 0) {
+            writer.uint32(8).int32(message.logType);
+        }
+        for (const v of message.exemptedMembers) {
+            writer.uint32(18).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAuditLogConfig();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.logType = reader.int32();
+                    break;
+                case 2:
+                    message.exemptedMembers.push(reader.string());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAuditLogConfig();
+        message.logType = object.logType ?? 0;
+        message.exemptedMembers = object.exemptedMembers?.map(e => e) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAuditLogConfig();
+        if (object.log_type !== undefined && object.log_type !== null) {
+            message.logType = object.log_type;
+        }
+        message.exemptedMembers = object.exempted_members?.map(e => e) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.log_type = message.logType === 0 ? undefined : message.logType;
+        if (message.exemptedMembers) {
+            obj.exempted_members = message.exemptedMembers.map(e => e);
+        }
+        else {
+            obj.exempted_members = message.exemptedMembers;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return AuditLogConfig.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return AuditLogConfig.decode(message.value);
+    },
+    toProto(message) {
+        return AuditLogConfig.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.iam.v1.AuditLogConfig",
+            value: AuditLogConfig.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};
+function createBasePolicyDelta() {
+    return {
+        bindingDeltas: [],
+        auditConfigDeltas: []
+    };
+}
+/**
+ * The difference delta between two policies.
+ * @name PolicyDelta
+ * @package google.iam.v1
+ * @see proto type: google.iam.v1.PolicyDelta
+ */
+export const PolicyDelta = {
+    typeUrl: "/google.iam.v1.PolicyDelta",
+    is(o) {
+        return o && (o.$typeUrl === PolicyDelta.typeUrl || Array.isArray(o.bindingDeltas) && (!o.bindingDeltas.length || BindingDelta.is(o.bindingDeltas[0])) && Array.isArray(o.auditConfigDeltas) && (!o.auditConfigDeltas.length || AuditConfigDelta.is(o.auditConfigDeltas[0])));
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === PolicyDelta.typeUrl || Array.isArray(o.binding_deltas) && (!o.binding_deltas.length || BindingDelta.isAmino(o.binding_deltas[0])) && Array.isArray(o.audit_config_deltas) && (!o.audit_config_deltas.length || AuditConfigDelta.isAmino(o.audit_config_deltas[0])));
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        for (const v of message.bindingDeltas) {
+            BindingDelta.encode(v, writer.uint32(10).fork()).ldelim();
+        }
+        for (const v of message.auditConfigDeltas) {
+            AuditConfigDelta.encode(v, writer.uint32(18).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBasePolicyDelta();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.bindingDeltas.push(BindingDelta.decode(reader, reader.uint32()));
+                    break;
+                case 2:
+                    message.auditConfigDeltas.push(AuditConfigDelta.decode(reader, reader.uint32()));
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBasePolicyDelta();
+        message.bindingDeltas = object.bindingDeltas?.map(e => BindingDelta.fromPartial(e)) || [];
+        message.auditConfigDeltas = object.auditConfigDeltas?.map(e => AuditConfigDelta.fromPartial(e)) || [];
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBasePolicyDelta();
+        message.bindingDeltas = object.binding_deltas?.map(e => BindingDelta.fromAmino(e)) || [];
+        message.auditConfigDeltas = object.audit_config_deltas?.map(e => AuditConfigDelta.fromAmino(e)) || [];
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        if (message.bindingDeltas) {
+            obj.binding_deltas = message.bindingDeltas.map(e => e ? BindingDelta.toAmino(e) : undefined);
+        }
+        else {
+            obj.binding_deltas = message.bindingDeltas;
+        }
+        if (message.auditConfigDeltas) {
+            obj.audit_config_deltas = message.auditConfigDeltas.map(e => e ? AuditConfigDelta.toAmino(e) : undefined);
+        }
+        else {
+            obj.audit_config_deltas = message.auditConfigDeltas;
+        }
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return PolicyDelta.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return PolicyDelta.decode(message.value);
+    },
+    toProto(message) {
+        return PolicyDelta.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.iam.v1.PolicyDelta",
+            value: PolicyDelta.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(PolicyDelta.typeUrl)) {
+            return;
+        }
+        BindingDelta.registerTypeUrl();
+        AuditConfigDelta.registerTypeUrl();
+    }
+};
+function createBaseBindingDelta() {
+    return {
+        action: 0,
+        role: "",
+        member: "",
+        condition: undefined
+    };
+}
+/**
+ * One delta entry for Binding. Each individual change (only one member in each
+ * entry) to a binding will be a separate entry.
+ * @name BindingDelta
+ * @package google.iam.v1
+ * @see proto type: google.iam.v1.BindingDelta
+ */
+export const BindingDelta = {
+    typeUrl: "/google.iam.v1.BindingDelta",
+    is(o) {
+        return o && (o.$typeUrl === BindingDelta.typeUrl || isSet(o.action) && typeof o.role === "string" && typeof o.member === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === BindingDelta.typeUrl || isSet(o.action) && typeof o.role === "string" && typeof o.member === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.action !== 0) {
+            writer.uint32(8).int32(message.action);
+        }
+        if (message.role !== "") {
+            writer.uint32(18).string(message.role);
+        }
+        if (message.member !== "") {
+            writer.uint32(26).string(message.member);
+        }
+        if (message.condition !== undefined) {
+            Expr.encode(message.condition, writer.uint32(34).fork()).ldelim();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBindingDelta();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.action = reader.int32();
+                    break;
+                case 2:
+                    message.role = reader.string();
+                    break;
+                case 3:
+                    message.member = reader.string();
+                    break;
+                case 4:
+                    message.condition = Expr.decode(reader, reader.uint32());
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseBindingDelta();
+        message.action = object.action ?? 0;
+        message.role = object.role ?? "";
+        message.member = object.member ?? "";
+        message.condition = object.condition !== undefined && object.condition !== null ? Expr.fromPartial(object.condition) : undefined;
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseBindingDelta();
+        if (object.action !== undefined && object.action !== null) {
+            message.action = object.action;
+        }
+        if (object.role !== undefined && object.role !== null) {
+            message.role = object.role;
+        }
+        if (object.member !== undefined && object.member !== null) {
+            message.member = object.member;
+        }
+        if (object.condition !== undefined && object.condition !== null) {
+            message.condition = Expr.fromAmino(object.condition);
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.action = message.action === 0 ? undefined : message.action;
+        obj.role = message.role === "" ? undefined : message.role;
+        obj.member = message.member === "" ? undefined : message.member;
+        obj.condition = message.condition ? Expr.toAmino(message.condition) : undefined;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return BindingDelta.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return BindingDelta.decode(message.value);
+    },
+    toProto(message) {
+        return BindingDelta.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.iam.v1.BindingDelta",
+            value: BindingDelta.encode(message).finish()
+        };
+    },
+    registerTypeUrl() {
+        if (!GlobalDecoderRegistry.registerExistingTypeUrl(BindingDelta.typeUrl)) {
+            return;
+        }
+        Expr.registerTypeUrl();
+    }
+};
+function createBaseAuditConfigDelta() {
+    return {
+        action: 0,
+        service: "",
+        exemptedMember: "",
+        logType: ""
+    };
+}
+/**
+ * One delta entry for AuditConfig. Each individual change (only one
+ * exempted_member in each entry) to a AuditConfig will be a separate entry.
+ * @name AuditConfigDelta
+ * @package google.iam.v1
+ * @see proto type: google.iam.v1.AuditConfigDelta
+ */
+export const AuditConfigDelta = {
+    typeUrl: "/google.iam.v1.AuditConfigDelta",
+    is(o) {
+        return o && (o.$typeUrl === AuditConfigDelta.typeUrl || isSet(o.action) && typeof o.service === "string" && typeof o.exemptedMember === "string" && typeof o.logType === "string");
+    },
+    isAmino(o) {
+        return o && (o.$typeUrl === AuditConfigDelta.typeUrl || isSet(o.action) && typeof o.service === "string" && typeof o.exempted_member === "string" && typeof o.log_type === "string");
+    },
+    encode(message, writer = BinaryWriter.create()) {
+        if (message.action !== 0) {
+            writer.uint32(8).int32(message.action);
+        }
+        if (message.service !== "") {
+            writer.uint32(18).string(message.service);
+        }
+        if (message.exemptedMember !== "") {
+            writer.uint32(26).string(message.exemptedMember);
+        }
+        if (message.logType !== "") {
+            writer.uint32(34).string(message.logType);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        let end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAuditConfigDelta();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.action = reader.int32();
+                    break;
+                case 2:
+                    message.service = reader.string();
+                    break;
+                case 3:
+                    message.exemptedMember = reader.string();
+                    break;
+                case 4:
+                    message.logType = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromPartial(object) {
+        const message = createBaseAuditConfigDelta();
+        message.action = object.action ?? 0;
+        message.service = object.service ?? "";
+        message.exemptedMember = object.exemptedMember ?? "";
+        message.logType = object.logType ?? "";
+        return message;
+    },
+    fromAmino(object) {
+        const message = createBaseAuditConfigDelta();
+        if (object.action !== undefined && object.action !== null) {
+            message.action = object.action;
+        }
+        if (object.service !== undefined && object.service !== null) {
+            message.service = object.service;
+        }
+        if (object.exempted_member !== undefined && object.exempted_member !== null) {
+            message.exemptedMember = object.exempted_member;
+        }
+        if (object.log_type !== undefined && object.log_type !== null) {
+            message.logType = object.log_type;
+        }
+        return message;
+    },
+    toAmino(message) {
+        const obj = {};
+        obj.action = message.action === 0 ? undefined : message.action;
+        obj.service = message.service === "" ? undefined : message.service;
+        obj.exempted_member = message.exemptedMember === "" ? undefined : message.exemptedMember;
+        obj.log_type = message.logType === "" ? undefined : message.logType;
+        return obj;
+    },
+    fromAminoMsg(object) {
+        return AuditConfigDelta.fromAmino(object.value);
+    },
+    fromProtoMsg(message) {
+        return AuditConfigDelta.decode(message.value);
+    },
+    toProto(message) {
+        return AuditConfigDelta.encode(message).finish();
+    },
+    toProtoMsg(message) {
+        return {
+            typeUrl: "/google.iam.v1.AuditConfigDelta",
+            value: AuditConfigDelta.encode(message).finish()
+        };
+    },
+    registerTypeUrl() { }
+};