@cratis/chronicle.contracts 0.0.0

package/dist/generated/observation_webhooks.js

@@ -0,0 +1,1321 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { makeGenericClientConstructor, } from "@grpc/grpc-js";
+import { Empty } from "./google/protobuf/empty";
+export const protobufPackage = "Cratis.Chronicle.Contracts.Observation.Webhooks";
+export var ObserverOwner;
+(function (ObserverOwner) {
+    ObserverOwner[ObserverOwner["None"] = 0] = "None";
+    ObserverOwner[ObserverOwner["Client"] = 1] = "Client";
+    ObserverOwner[ObserverOwner["Kernel"] = 2] = "Kernel";
+    ObserverOwner[ObserverOwner["UNRECOGNIZED"] = -1] = "UNRECOGNIZED";
+})(ObserverOwner || (ObserverOwner = {}));
+export function observerOwnerFromJSON(object) {
+    switch (object) {
+        case 0:
+        case "None":
+            return ObserverOwner.None;
+        case 1:
+        case "Client":
+            return ObserverOwner.Client;
+        case 2:
+        case "Kernel":
+            return ObserverOwner.Kernel;
+        case -1:
+        case "UNRECOGNIZED":
+        default:
+            return ObserverOwner.UNRECOGNIZED;
+    }
+}
+export function observerOwnerToJSON(object) {
+    switch (object) {
+        case ObserverOwner.None:
+            return "None";
+        case ObserverOwner.Client:
+            return "Client";
+        case ObserverOwner.Kernel:
+            return "Kernel";
+        case ObserverOwner.UNRECOGNIZED:
+        default:
+            return "UNRECOGNIZED";
+    }
+}
+function createBaseAddWebhooks() {
+    return { EventStore: "", Owner: 0, Webhooks: [] };
+}
+export const AddWebhooks = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        if (message.Owner !== 0) {
+            writer.uint32(16).int32(message.Owner);
+        }
+        for (const v of message.Webhooks) {
+            WebhookDefinition.encode(v, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseAddWebhooks();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.Owner = reader.int32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.Webhooks.push(WebhookDefinition.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Owner: isSet(object.Owner) ? observerOwnerFromJSON(object.Owner) : 0,
+            Webhooks: globalThis.Array.isArray(object?.Webhooks)
+                ? object.Webhooks.map((e) => WebhookDefinition.fromJSON(e))
+                : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Owner !== 0) {
+            obj.Owner = observerOwnerToJSON(message.Owner);
+        }
+        if (message.Webhooks?.length) {
+            obj.Webhooks = message.Webhooks.map((e) => WebhookDefinition.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return AddWebhooks.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseAddWebhooks();
+        message.EventStore = object.EventStore ?? "";
+        message.Owner = object.Owner ?? 0;
+        message.Webhooks = object.Webhooks?.map((e) => WebhookDefinition.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseBasicAuthorization() {
+    return { Username: "", Password: "" };
+}
+export const BasicAuthorization = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Username !== "") {
+            writer.uint32(10).string(message.Username);
+        }
+        if (message.Password !== "") {
+            writer.uint32(18).string(message.Password);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBasicAuthorization();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Username = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Password = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Username: isSet(object.Username) ? globalThis.String(object.Username) : "",
+            Password: isSet(object.Password) ? globalThis.String(object.Password) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Username !== "") {
+            obj.Username = message.Username;
+        }
+        if (message.Password !== "") {
+            obj.Password = message.Password;
+        }
+        return obj;
+    },
+    create(base) {
+        return BasicAuthorization.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseBasicAuthorization();
+        message.Username = object.Username ?? "";
+        message.Password = object.Password ?? "";
+        return message;
+    },
+};
+function createBaseBearerTokenAuthorization() {
+    return { Token: "" };
+}
+export const BearerTokenAuthorization = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Token !== "") {
+            writer.uint32(10).string(message.Token);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBearerTokenAuthorization();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Token = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { Token: isSet(object.Token) ? globalThis.String(object.Token) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Token !== "") {
+            obj.Token = message.Token;
+        }
+        return obj;
+    },
+    create(base) {
+        return BearerTokenAuthorization.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseBearerTokenAuthorization();
+        message.Token = object.Token ?? "";
+        return message;
+    },
+};
+function createBaseEventType() {
+    return { Id: "", Generation: 0, Tombstone: false };
+}
+export const EventType = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Id !== "") {
+            writer.uint32(10).string(message.Id);
+        }
+        if (message.Generation !== 0) {
+            writer.uint32(16).uint32(message.Generation);
+        }
+        if (message.Tombstone !== false) {
+            writer.uint32(24).bool(message.Tombstone);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEventType();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Id = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 16) {
+                        break;
+                    }
+                    message.Generation = reader.uint32();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 24) {
+                        break;
+                    }
+                    message.Tombstone = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Id: isSet(object.Id) ? globalThis.String(object.Id) : "",
+            Generation: isSet(object.Generation) ? globalThis.Number(object.Generation) : 0,
+            Tombstone: isSet(object.Tombstone) ? globalThis.Boolean(object.Tombstone) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Id !== "") {
+            obj.Id = message.Id;
+        }
+        if (message.Generation !== 0) {
+            obj.Generation = Math.round(message.Generation);
+        }
+        if (message.Tombstone !== false) {
+            obj.Tombstone = message.Tombstone;
+        }
+        return obj;
+    },
+    create(base) {
+        return EventType.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseEventType();
+        message.Id = object.Id ?? "";
+        message.Generation = object.Generation ?? 0;
+        message.Tombstone = object.Tombstone ?? false;
+        return message;
+    },
+};
+function createBaseGetWebhooksRequest() {
+    return { EventStore: "" };
+}
+export const GetWebhooksRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseGetWebhooksRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "" };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        return obj;
+    },
+    create(base) {
+        return GetWebhooksRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseGetWebhooksRequest();
+        message.EventStore = object.EventStore ?? "";
+        return message;
+    },
+};
+function createBaseIEnumerableWebhookDefinition() {
+    return { items: [] };
+}
+export const IEnumerableWebhookDefinition = {
+    encode(message, writer = new BinaryWriter()) {
+        for (const v of message.items) {
+            WebhookDefinition.encode(v, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseIEnumerableWebhookDefinition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.items.push(WebhookDefinition.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            items: globalThis.Array.isArray(object?.items) ? object.items.map((e) => WebhookDefinition.fromJSON(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.items?.length) {
+            obj.items = message.items.map((e) => WebhookDefinition.toJSON(e));
+        }
+        return obj;
+    },
+    create(base) {
+        return IEnumerableWebhookDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseIEnumerableWebhookDefinition();
+        message.items = object.items?.map((e) => WebhookDefinition.fromPartial(e)) || [];
+        return message;
+    },
+};
+function createBaseOAuthAuthorization() {
+    return { Authority: "", ClientId: "", ClientSecret: "" };
+}
+export const OAuthAuthorization = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Authority !== "") {
+            writer.uint32(10).string(message.Authority);
+        }
+        if (message.ClientId !== "") {
+            writer.uint32(18).string(message.ClientId);
+        }
+        if (message.ClientSecret !== "") {
+            writer.uint32(26).string(message.ClientSecret);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOAuthAuthorization();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Authority = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ClientId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.ClientSecret = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Authority: isSet(object.Authority) ? globalThis.String(object.Authority) : "",
+            ClientId: isSet(object.ClientId) ? globalThis.String(object.ClientId) : "",
+            ClientSecret: isSet(object.ClientSecret) ? globalThis.String(object.ClientSecret) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Authority !== "") {
+            obj.Authority = message.Authority;
+        }
+        if (message.ClientId !== "") {
+            obj.ClientId = message.ClientId;
+        }
+        if (message.ClientSecret !== "") {
+            obj.ClientSecret = message.ClientSecret;
+        }
+        return obj;
+    },
+    create(base) {
+        return OAuthAuthorization.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseOAuthAuthorization();
+        message.Authority = object.Authority ?? "";
+        message.ClientId = object.ClientId ?? "";
+        message.ClientSecret = object.ClientSecret ?? "";
+        return message;
+    },
+};
+function createBaseOneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization() {
+    return { Value0: undefined, Value1: undefined, Value2: undefined };
+}
+export const OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Value0 !== undefined) {
+            BasicAuthorization.encode(message.Value0, writer.uint32(10).fork()).join();
+        }
+        if (message.Value1 !== undefined) {
+            BearerTokenAuthorization.encode(message.Value1, writer.uint32(18).fork()).join();
+        }
+        if (message.Value2 !== undefined) {
+            OAuthAuthorization.encode(message.Value2, writer.uint32(26).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseOneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Value0 = BasicAuthorization.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Value1 = BearerTokenAuthorization.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.Value2 = OAuthAuthorization.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Value0: isSet(object.Value0) ? BasicAuthorization.fromJSON(object.Value0) : undefined,
+            Value1: isSet(object.Value1) ? BearerTokenAuthorization.fromJSON(object.Value1) : undefined,
+            Value2: isSet(object.Value2) ? OAuthAuthorization.fromJSON(object.Value2) : undefined,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Value0 !== undefined) {
+            obj.Value0 = BasicAuthorization.toJSON(message.Value0);
+        }
+        if (message.Value1 !== undefined) {
+            obj.Value1 = BearerTokenAuthorization.toJSON(message.Value1);
+        }
+        if (message.Value2 !== undefined) {
+            obj.Value2 = OAuthAuthorization.toJSON(message.Value2);
+        }
+        return obj;
+    },
+    create(base) {
+        return OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseOneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization();
+        message.Value0 = (object.Value0 !== undefined && object.Value0 !== null)
+            ? BasicAuthorization.fromPartial(object.Value0)
+            : undefined;
+        message.Value1 = (object.Value1 !== undefined && object.Value1 !== null)
+            ? BearerTokenAuthorization.fromPartial(object.Value1)
+            : undefined;
+        message.Value2 = (object.Value2 !== undefined && object.Value2 !== null)
+            ? OAuthAuthorization.fromPartial(object.Value2)
+            : undefined;
+        return message;
+    },
+};
+function createBaseRemoveWebhooks() {
+    return { EventStore: "", Webhooks: [] };
+}
+export const RemoveWebhooks = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventStore !== "") {
+            writer.uint32(10).string(message.EventStore);
+        }
+        for (const v of message.Webhooks) {
+            writer.uint32(26).string(v);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseRemoveWebhooks();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventStore = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.Webhooks.push(reader.string());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventStore: isSet(object.EventStore) ? globalThis.String(object.EventStore) : "",
+            Webhooks: globalThis.Array.isArray(object?.Webhooks) ? object.Webhooks.map((e) => globalThis.String(e)) : [],
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventStore !== "") {
+            obj.EventStore = message.EventStore;
+        }
+        if (message.Webhooks?.length) {
+            obj.Webhooks = message.Webhooks;
+        }
+        return obj;
+    },
+    create(base) {
+        return RemoveWebhooks.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseRemoveWebhooks();
+        message.EventStore = object.EventStore ?? "";
+        message.Webhooks = object.Webhooks?.map((e) => e) || [];
+        return message;
+    },
+};
+function createBaseTestOAuthAuthorizationRequest() {
+    return { Authority: "", ClientId: "", ClientSecret: "" };
+}
+export const TestOAuthAuthorizationRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Authority !== "") {
+            writer.uint32(10).string(message.Authority);
+        }
+        if (message.ClientId !== "") {
+            writer.uint32(18).string(message.ClientId);
+        }
+        if (message.ClientSecret !== "") {
+            writer.uint32(26).string(message.ClientSecret);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTestOAuthAuthorizationRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Authority = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ClientId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.ClientSecret = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Authority: isSet(object.Authority) ? globalThis.String(object.Authority) : "",
+            ClientId: isSet(object.ClientId) ? globalThis.String(object.ClientId) : "",
+            ClientSecret: isSet(object.ClientSecret) ? globalThis.String(object.ClientSecret) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Authority !== "") {
+            obj.Authority = message.Authority;
+        }
+        if (message.ClientId !== "") {
+            obj.ClientId = message.ClientId;
+        }
+        if (message.ClientSecret !== "") {
+            obj.ClientSecret = message.ClientSecret;
+        }
+        return obj;
+    },
+    create(base) {
+        return TestOAuthAuthorizationRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTestOAuthAuthorizationRequest();
+        message.Authority = object.Authority ?? "";
+        message.ClientId = object.ClientId ?? "";
+        message.ClientSecret = object.ClientSecret ?? "";
+        return message;
+    },
+};
+function createBaseTestOAuthAuthorizationResponse() {
+    return { Success: false, ErrorMessage: "" };
+}
+export const TestOAuthAuthorizationResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Success !== false) {
+            writer.uint32(8).bool(message.Success);
+        }
+        if (message.ErrorMessage !== "") {
+            writer.uint32(18).string(message.ErrorMessage);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTestOAuthAuthorizationResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.Success = reader.bool();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ErrorMessage = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Success: isSet(object.Success) ? globalThis.Boolean(object.Success) : false,
+            ErrorMessage: isSet(object.ErrorMessage) ? globalThis.String(object.ErrorMessage) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Success !== false) {
+            obj.Success = message.Success;
+        }
+        if (message.ErrorMessage !== "") {
+            obj.ErrorMessage = message.ErrorMessage;
+        }
+        return obj;
+    },
+    create(base) {
+        return TestOAuthAuthorizationResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTestOAuthAuthorizationResponse();
+        message.Success = object.Success ?? false;
+        message.ErrorMessage = object.ErrorMessage ?? "";
+        return message;
+    },
+};
+function createBaseTestWebhookRequest() {
+    return { Target: undefined };
+}
+export const TestWebhookRequest = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Target !== undefined) {
+            WebhookTarget.encode(message.Target, writer.uint32(10).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTestWebhookRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Target = WebhookTarget.decode(reader, reader.uint32());
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return { Target: isSet(object.Target) ? WebhookTarget.fromJSON(object.Target) : undefined };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Target !== undefined) {
+            obj.Target = WebhookTarget.toJSON(message.Target);
+        }
+        return obj;
+    },
+    create(base) {
+        return TestWebhookRequest.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTestWebhookRequest();
+        message.Target = (object.Target !== undefined && object.Target !== null)
+            ? WebhookTarget.fromPartial(object.Target)
+            : undefined;
+        return message;
+    },
+};
+function createBaseTestWebhookResponse() {
+    return { Success: false, ErrorMessage: "" };
+}
+export const TestWebhookResponse = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Success !== false) {
+            writer.uint32(8).bool(message.Success);
+        }
+        if (message.ErrorMessage !== "") {
+            writer.uint32(18).string(message.ErrorMessage);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseTestWebhookResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.Success = reader.bool();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.ErrorMessage = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Success: isSet(object.Success) ? globalThis.Boolean(object.Success) : false,
+            ErrorMessage: isSet(object.ErrorMessage) ? globalThis.String(object.ErrorMessage) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Success !== false) {
+            obj.Success = message.Success;
+        }
+        if (message.ErrorMessage !== "") {
+            obj.ErrorMessage = message.ErrorMessage;
+        }
+        return obj;
+    },
+    create(base) {
+        return TestWebhookResponse.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseTestWebhookResponse();
+        message.Success = object.Success ?? false;
+        message.ErrorMessage = object.ErrorMessage ?? "";
+        return message;
+    },
+};
+function createBaseWebhookDefinition() {
+    return {
+        EventSequenceId: "",
+        Identifier: "",
+        EventTypes: [],
+        Target: undefined,
+        IsReplayable: false,
+        IsActive: false,
+    };
+}
+export const WebhookDefinition = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.EventSequenceId !== "") {
+            writer.uint32(10).string(message.EventSequenceId);
+        }
+        if (message.Identifier !== "") {
+            writer.uint32(18).string(message.Identifier);
+        }
+        for (const v of message.EventTypes) {
+            EventType.encode(v, writer.uint32(26).fork()).join();
+        }
+        if (message.Target !== undefined) {
+            WebhookTarget.encode(message.Target, writer.uint32(34).fork()).join();
+        }
+        if (message.IsReplayable !== false) {
+            writer.uint32(40).bool(message.IsReplayable);
+        }
+        if (message.IsActive !== false) {
+            writer.uint32(48).bool(message.IsActive);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWebhookDefinition();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.EventSequenceId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Identifier = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.EventTypes.push(EventType.decode(reader, reader.uint32()));
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.Target = WebhookTarget.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 40) {
+                        break;
+                    }
+                    message.IsReplayable = reader.bool();
+                    continue;
+                }
+                case 6: {
+                    if (tag !== 48) {
+                        break;
+                    }
+                    message.IsActive = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            EventSequenceId: isSet(object.EventSequenceId) ? globalThis.String(object.EventSequenceId) : "",
+            Identifier: isSet(object.Identifier) ? globalThis.String(object.Identifier) : "",
+            EventTypes: globalThis.Array.isArray(object?.EventTypes)
+                ? object.EventTypes.map((e) => EventType.fromJSON(e))
+                : [],
+            Target: isSet(object.Target) ? WebhookTarget.fromJSON(object.Target) : undefined,
+            IsReplayable: isSet(object.IsReplayable) ? globalThis.Boolean(object.IsReplayable) : false,
+            IsActive: isSet(object.IsActive) ? globalThis.Boolean(object.IsActive) : false,
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.EventSequenceId !== "") {
+            obj.EventSequenceId = message.EventSequenceId;
+        }
+        if (message.Identifier !== "") {
+            obj.Identifier = message.Identifier;
+        }
+        if (message.EventTypes?.length) {
+            obj.EventTypes = message.EventTypes.map((e) => EventType.toJSON(e));
+        }
+        if (message.Target !== undefined) {
+            obj.Target = WebhookTarget.toJSON(message.Target);
+        }
+        if (message.IsReplayable !== false) {
+            obj.IsReplayable = message.IsReplayable;
+        }
+        if (message.IsActive !== false) {
+            obj.IsActive = message.IsActive;
+        }
+        return obj;
+    },
+    create(base) {
+        return WebhookDefinition.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWebhookDefinition();
+        message.EventSequenceId = object.EventSequenceId ?? "";
+        message.Identifier = object.Identifier ?? "";
+        message.EventTypes = object.EventTypes?.map((e) => EventType.fromPartial(e)) || [];
+        message.Target = (object.Target !== undefined && object.Target !== null)
+            ? WebhookTarget.fromPartial(object.Target)
+            : undefined;
+        message.IsReplayable = object.IsReplayable ?? false;
+        message.IsActive = object.IsActive ?? false;
+        return message;
+    },
+};
+function createBaseWebhookTarget() {
+    return { Url: "", Authorization: undefined, Headers: {} };
+}
+export const WebhookTarget = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.Url !== "") {
+            writer.uint32(10).string(message.Url);
+        }
+        if (message.Authorization !== undefined) {
+            OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.encode(message.Authorization, writer.uint32(18).fork()).join();
+        }
+        globalThis.Object.entries(message.Headers).forEach(([key, value]) => {
+            WebhookTarget_HeadersEntry.encode({ key: key, value }, writer.uint32(26).fork()).join();
+        });
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWebhookTarget();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.Url = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.Authorization = OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.decode(reader, reader.uint32());
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    const entry3 = WebhookTarget_HeadersEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.Headers[entry3.key] = entry3.value;
+                    }
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            Url: isSet(object.Url) ? globalThis.String(object.Url) : "",
+            Authorization: isSet(object.Authorization)
+                ? OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.fromJSON(object.Authorization)
+                : undefined,
+            Headers: isObject(object.Headers)
+                ? globalThis.Object.entries(object.Headers).reduce((acc, [key, value]) => {
+                    acc[key] = globalThis.String(value);
+                    return acc;
+                }, {})
+                : {},
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.Url !== "") {
+            obj.Url = message.Url;
+        }
+        if (message.Authorization !== undefined) {
+            obj.Authorization = OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.toJSON(message.Authorization);
+        }
+        if (message.Headers) {
+            const entries = globalThis.Object.entries(message.Headers);
+            if (entries.length > 0) {
+                obj.Headers = {};
+                entries.forEach(([k, v]) => {
+                    obj.Headers[k] = v;
+                });
+            }
+        }
+        return obj;
+    },
+    create(base) {
+        return WebhookTarget.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWebhookTarget();
+        message.Url = object.Url ?? "";
+        message.Authorization = (object.Authorization !== undefined && object.Authorization !== null)
+            ? OneOfBasicAuthorizationBearerTokenAuthorizationOAuthAuthorization.fromPartial(object.Authorization)
+            : undefined;
+        message.Headers = globalThis.Object.entries(object.Headers ?? {}).reduce((acc, [key, value]) => {
+            if (value !== undefined) {
+                acc[key] = globalThis.String(value);
+            }
+            return acc;
+        }, {});
+        return message;
+    },
+};
+function createBaseWebhookTarget_HeadersEntry() {
+    return { key: "", value: "" };
+}
+export const WebhookTarget_HeadersEntry = {
+    encode(message, writer = new BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseWebhookTarget_HeadersEntry();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.key = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.value = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            key: isSet(object.key) ? globalThis.String(object.key) : "",
+            value: isSet(object.value) ? globalThis.String(object.value) : "",
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        if (message.key !== "") {
+            obj.key = message.key;
+        }
+        if (message.value !== "") {
+            obj.value = message.value;
+        }
+        return obj;
+    },
+    create(base) {
+        return WebhookTarget_HeadersEntry.fromPartial(base ?? {});
+    },
+    fromPartial(object) {
+        const message = createBaseWebhookTarget_HeadersEntry();
+        message.key = object.key ?? "";
+        message.value = object.value ?? "";
+        return message;
+    },
+};
+export const WebhooksService = {
+    add: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks/Add",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(AddWebhooks.encode(value).finish()),
+        requestDeserialize: (value) => AddWebhooks.decode(value),
+        responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
+        responseDeserialize: (value) => Empty.decode(value),
+    },
+    getWebhooks: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks/GetWebhooks",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(GetWebhooksRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetWebhooksRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableWebhookDefinition.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableWebhookDefinition.decode(value),
+    },
+    observeWebhooks: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks/ObserveWebhooks",
+        requestStream: false,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(GetWebhooksRequest.encode(value).finish()),
+        requestDeserialize: (value) => GetWebhooksRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(IEnumerableWebhookDefinition.encode(value).finish()),
+        responseDeserialize: (value) => IEnumerableWebhookDefinition.decode(value),
+    },
+    remove: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks/Remove",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(RemoveWebhooks.encode(value).finish()),
+        requestDeserialize: (value) => RemoveWebhooks.decode(value),
+        responseSerialize: (value) => Buffer.from(Empty.encode(value).finish()),
+        responseDeserialize: (value) => Empty.decode(value),
+    },
+    testOAuthAuthorization: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks/TestOAuthAuthorization",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(TestOAuthAuthorizationRequest.encode(value).finish()),
+        requestDeserialize: (value) => TestOAuthAuthorizationRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(TestOAuthAuthorizationResponse.encode(value).finish()),
+        responseDeserialize: (value) => TestOAuthAuthorizationResponse.decode(value),
+    },
+    testWebhook: {
+        path: "/Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks/TestWebhook",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(TestWebhookRequest.encode(value).finish()),
+        requestDeserialize: (value) => TestWebhookRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(TestWebhookResponse.encode(value).finish()),
+        responseDeserialize: (value) => TestWebhookResponse.decode(value),
+    },
+};
+export const WebhooksClient = makeGenericClientConstructor(WebhooksService, "Cratis.Chronicle.Contracts.Observation.Webhooks.Webhooks");
+function isObject(value) {
+    return typeof value === "object" && value !== null;
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}
+//# sourceMappingURL=observation_webhooks.js.map