@authzed/authzed-js-node/src/authzedapi/authzed/api/v1/experimental_service.js

authzed js client for nodejs

// @generated by protobuf-ts 2.9.1 with parameter generate_dependencies,long_type_string,client_grpc1
// @generated from protobuf file "authzed/api/v1/experimental_service.proto" (package "authzed.api.v1", syntax proto3)
// tslint:disable
import { ServiceType } from "@protobuf-ts/runtime-rpc";
import { WireType } from "@protobuf-ts/runtime";
import { UnknownFieldHandler } from "@protobuf-ts/runtime";
import { reflectionMergePartial } from "@protobuf-ts/runtime";
import { MESSAGE_TYPE } from "@protobuf-ts/runtime";
import { MessageType } from "@protobuf-ts/runtime";
import { Cursor } from "./core.js";
import { Relationship } from "./core.js";
import { PartialCaveatInfo } from "./core.js";
import { CheckPermissionResponse_Permissionship } from "./permission_service.js";
import { Status } from "../../../google/rpc/status.js";
import { Struct } from "../../../google/protobuf/struct.js";
import { SubjectReference } from "./core.js";
import { ObjectReference } from "./core.js";
import { Consistency } from "./permission_service.js";
import { ZedToken } from "./core.js";
import { RelationshipFilter } from "./permission_service.js";
// @generated message type with reflection information, may provide speed optimized methods
class ExperimentalRegisterRelationshipCounterRequest$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ExperimentalRegisterRelationshipCounterRequest", [
            { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { maxBytes: "64", pattern: "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$" } }, "validate.rules": { string: { maxBytes: "64", pattern: "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$" } } } },
            { no: 2, name: "relationship_filter", kind: "message", T: () => RelationshipFilter, options: { "buf.validate.field": { required: true }, "validate.rules": { message: { required: true } } } }
        ]);
    }
    create(value) {
        const message = { name: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string name */ 1:
                    message.name = reader.string();
                    break;
                case /* authzed.api.v1.RelationshipFilter relationship_filter */ 2:
                    message.relationshipFilter = RelationshipFilter.internalBinaryRead(reader, reader.uint32(), options, message.relationshipFilter);
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* string name = 1; */
        if (message.name !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.name);
        /* authzed.api.v1.RelationshipFilter relationship_filter = 2; */
        if (message.relationshipFilter)
            RelationshipFilter.internalBinaryWrite(message.relationshipFilter, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.ExperimentalRegisterRelationshipCounterRequest
 */
export const ExperimentalRegisterRelationshipCounterRequest = new ExperimentalRegisterRelationshipCounterRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExperimentalRegisterRelationshipCounterResponse$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ExperimentalRegisterRelationshipCounterResponse", []);
    }
    create(value) {
        const message = {};
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        return target ?? this.create();
    }
    internalBinaryWrite(message, writer, options) {
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.ExperimentalRegisterRelationshipCounterResponse
 */
export const ExperimentalRegisterRelationshipCounterResponse = new ExperimentalRegisterRelationshipCounterResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExperimentalCountRelationshipsRequest$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ExperimentalCountRelationshipsRequest", [
            { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { maxBytes: "64", pattern: "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$" } }, "validate.rules": { string: { maxBytes: "64", pattern: "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$" } } } }
        ]);
    }
    create(value) {
        const message = { name: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string name */ 1:
                    message.name = reader.string();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* string name = 1; */
        if (message.name !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.name);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.ExperimentalCountRelationshipsRequest
 */
export const ExperimentalCountRelationshipsRequest = new ExperimentalCountRelationshipsRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExperimentalCountRelationshipsResponse$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ExperimentalCountRelationshipsResponse", [
            { no: 1, name: "counter_still_calculating", kind: "scalar", oneof: "counterResult", T: 8 /*ScalarType.BOOL*/ },
            { no: 2, name: "read_counter_value", kind: "message", oneof: "counterResult", T: () => ReadCounterValue }
        ]);
    }
    create(value) {
        const message = { counterResult: { oneofKind: undefined } };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* bool counter_still_calculating */ 1:
                    message.counterResult = {
                        oneofKind: "counterStillCalculating",
                        counterStillCalculating: reader.bool()
                    };
                    break;
                case /* authzed.api.v1.ReadCounterValue read_counter_value */ 2:
                    message.counterResult = {
                        oneofKind: "readCounterValue",
                        readCounterValue: ReadCounterValue.internalBinaryRead(reader, reader.uint32(), options, message.counterResult.readCounterValue)
                    };
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* bool counter_still_calculating = 1; */
        if (message.counterResult.oneofKind === "counterStillCalculating")
            writer.tag(1, WireType.Varint).bool(message.counterResult.counterStillCalculating);
        /* authzed.api.v1.ReadCounterValue read_counter_value = 2; */
        if (message.counterResult.oneofKind === "readCounterValue")
            ReadCounterValue.internalBinaryWrite(message.counterResult.readCounterValue, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.ExperimentalCountRelationshipsResponse
 */
export const ExperimentalCountRelationshipsResponse = new ExperimentalCountRelationshipsResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ReadCounterValue$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ReadCounterValue", [
            { no: 1, name: "relationship_count", kind: "scalar", T: 4 /*ScalarType.UINT64*/ },
            { no: 2, name: "read_at", kind: "message", T: () => ZedToken, options: { "buf.validate.field": { required: true }, "validate.rules": { message: { required: true } } } }
        ]);
    }
    create(value) {
        const message = { relationshipCount: "0" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* uint64 relationship_count */ 1:
                    message.relationshipCount = reader.uint64().toString();
                    break;
                case /* authzed.api.v1.ZedToken read_at */ 2:
                    message.readAt = ZedToken.internalBinaryRead(reader, reader.uint32(), options, message.readAt);
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* uint64 relationship_count = 1; */
        if (message.relationshipCount !== "0")
            writer.tag(1, WireType.Varint).uint64(message.relationshipCount);
        /* authzed.api.v1.ZedToken read_at = 2; */
        if (message.readAt)
            ZedToken.internalBinaryWrite(message.readAt, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.ReadCounterValue
 */
export const ReadCounterValue = new ReadCounterValue$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExperimentalUnregisterRelationshipCounterRequest$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ExperimentalUnregisterRelationshipCounterRequest", [
            { no: 1, name: "name", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { maxBytes: "64", pattern: "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$" } }, "validate.rules": { string: { maxBytes: "64", pattern: "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$" } } } }
        ]);
    }
    create(value) {
        const message = { name: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* string name */ 1:
                    message.name = reader.string();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* string name = 1; */
        if (message.name !== "")
            writer.tag(1, WireType.LengthDelimited).string(message.name);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.ExperimentalUnregisterRelationshipCounterRequest
 */
export const ExperimentalUnregisterRelationshipCounterRequest = new ExperimentalUnregisterRelationshipCounterRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExperimentalUnregisterRelationshipCounterResponse$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ExperimentalUnregisterRelationshipCounterResponse", []);
    }
    create(value) {
        const message = {};
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        return target ?? this.create();
    }
    internalBinaryWrite(message, writer, options) {
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.ExperimentalUnregisterRelationshipCounterResponse
 */
export const ExperimentalUnregisterRelationshipCounterResponse = new ExperimentalUnregisterRelationshipCounterResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkCheckPermissionRequest$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkCheckPermissionRequest", [
            { no: 1, name: "consistency", kind: "message", T: () => Consistency },
            { no: 2, name: "items", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => BulkCheckPermissionRequestItem, options: { "buf.validate.field": { repeated: { items: { required: true } } }, "validate.rules": { repeated: { items: { message: { required: true } } } } } }
        ]);
    }
    create(value) {
        const message = { items: [] };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* authzed.api.v1.Consistency consistency */ 1:
                    message.consistency = Consistency.internalBinaryRead(reader, reader.uint32(), options, message.consistency);
                    break;
                case /* repeated authzed.api.v1.BulkCheckPermissionRequestItem items = 2 [deprecated = true];*/ 2:
                    message.items.push(BulkCheckPermissionRequestItem.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* authzed.api.v1.Consistency consistency = 1; */
        if (message.consistency)
            Consistency.internalBinaryWrite(message.consistency, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* repeated authzed.api.v1.BulkCheckPermissionRequestItem items = 2 [deprecated = true]; */
        for (let i = 0; i < message.items.length; i++)
            BulkCheckPermissionRequestItem.internalBinaryWrite(message.items[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkCheckPermissionRequest
 */
export const BulkCheckPermissionRequest = new BulkCheckPermissionRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkCheckPermissionRequestItem$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkCheckPermissionRequestItem", [
            { no: 1, name: "resource", kind: "message", T: () => ObjectReference, options: { "buf.validate.field": { required: true }, "validate.rules": { message: { required: true } } } },
            { no: 2, name: "permission", kind: "scalar", T: 9 /*ScalarType.STRING*/, options: { "buf.validate.field": { string: { maxBytes: "64", pattern: "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$" } }, "validate.rules": { string: { maxBytes: "64", pattern: "^([a-z][a-z0-9_]{1,62}[a-z0-9])?$" } } } },
            { no: 3, name: "subject", kind: "message", T: () => SubjectReference, options: { "buf.validate.field": { required: true }, "validate.rules": { message: { required: true } } } },
            { no: 4, name: "context", kind: "message", T: () => Struct, options: { "buf.validate.field": { required: false }, "validate.rules": { message: { required: false } } } }
        ]);
    }
    create(value) {
        const message = { permission: "" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* authzed.api.v1.ObjectReference resource */ 1:
                    message.resource = ObjectReference.internalBinaryRead(reader, reader.uint32(), options, message.resource);
                    break;
                case /* string permission */ 2:
                    message.permission = reader.string();
                    break;
                case /* authzed.api.v1.SubjectReference subject */ 3:
                    message.subject = SubjectReference.internalBinaryRead(reader, reader.uint32(), options, message.subject);
                    break;
                case /* google.protobuf.Struct context */ 4:
                    message.context = Struct.internalBinaryRead(reader, reader.uint32(), options, message.context);
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* authzed.api.v1.ObjectReference resource = 1; */
        if (message.resource)
            ObjectReference.internalBinaryWrite(message.resource, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* string permission = 2; */
        if (message.permission !== "")
            writer.tag(2, WireType.LengthDelimited).string(message.permission);
        /* authzed.api.v1.SubjectReference subject = 3; */
        if (message.subject)
            SubjectReference.internalBinaryWrite(message.subject, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* google.protobuf.Struct context = 4; */
        if (message.context)
            Struct.internalBinaryWrite(message.context, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkCheckPermissionRequestItem
 */
export const BulkCheckPermissionRequestItem = new BulkCheckPermissionRequestItem$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkCheckPermissionResponse$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkCheckPermissionResponse", [
            { no: 1, name: "checked_at", kind: "message", T: () => ZedToken, options: { "buf.validate.field": { required: false }, "validate.rules": { message: { required: false } } } },
            { no: 2, name: "pairs", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => BulkCheckPermissionPair, options: { "buf.validate.field": { repeated: { items: { required: true } } }, "validate.rules": { repeated: { items: { message: { required: true } } } } } }
        ]);
    }
    create(value) {
        const message = { pairs: [] };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* authzed.api.v1.ZedToken checked_at */ 1:
                    message.checkedAt = ZedToken.internalBinaryRead(reader, reader.uint32(), options, message.checkedAt);
                    break;
                case /* repeated authzed.api.v1.BulkCheckPermissionPair pairs */ 2:
                    message.pairs.push(BulkCheckPermissionPair.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* authzed.api.v1.ZedToken checked_at = 1; */
        if (message.checkedAt)
            ZedToken.internalBinaryWrite(message.checkedAt, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* repeated authzed.api.v1.BulkCheckPermissionPair pairs = 2; */
        for (let i = 0; i < message.pairs.length; i++)
            BulkCheckPermissionPair.internalBinaryWrite(message.pairs[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkCheckPermissionResponse
 */
export const BulkCheckPermissionResponse = new BulkCheckPermissionResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkCheckPermissionPair$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkCheckPermissionPair", [
            { no: 1, name: "request", kind: "message", T: () => BulkCheckPermissionRequestItem },
            { no: 2, name: "item", kind: "message", oneof: "response", T: () => BulkCheckPermissionResponseItem },
            { no: 3, name: "error", kind: "message", oneof: "response", T: () => Status }
        ]);
    }
    create(value) {
        const message = { response: { oneofKind: undefined } };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* authzed.api.v1.BulkCheckPermissionRequestItem request */ 1:
                    message.request = BulkCheckPermissionRequestItem.internalBinaryRead(reader, reader.uint32(), options, message.request);
                    break;
                case /* authzed.api.v1.BulkCheckPermissionResponseItem item */ 2:
                    message.response = {
                        oneofKind: "item",
                        item: BulkCheckPermissionResponseItem.internalBinaryRead(reader, reader.uint32(), options, message.response.item)
                    };
                    break;
                case /* google.rpc.Status error */ 3:
                    message.response = {
                        oneofKind: "error",
                        error: Status.internalBinaryRead(reader, reader.uint32(), options, message.response.error)
                    };
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* authzed.api.v1.BulkCheckPermissionRequestItem request = 1; */
        if (message.request)
            BulkCheckPermissionRequestItem.internalBinaryWrite(message.request, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* authzed.api.v1.BulkCheckPermissionResponseItem item = 2; */
        if (message.response.oneofKind === "item")
            BulkCheckPermissionResponseItem.internalBinaryWrite(message.response.item, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        /* google.rpc.Status error = 3; */
        if (message.response.oneofKind === "error")
            Status.internalBinaryWrite(message.response.error, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkCheckPermissionPair
 */
export const BulkCheckPermissionPair = new BulkCheckPermissionPair$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkCheckPermissionResponseItem$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkCheckPermissionResponseItem", [
            { no: 1, name: "permissionship", kind: "enum", T: () => ["authzed.api.v1.CheckPermissionResponse.Permissionship", CheckPermissionResponse_Permissionship, "PERMISSIONSHIP_"], options: { "buf.validate.field": { enum: { definedOnly: true, notIn: [0] } }, "validate.rules": { enum: { definedOnly: true, notIn: [0] } } } },
            { no: 2, name: "partial_caveat_info", kind: "message", T: () => PartialCaveatInfo, options: { "buf.validate.field": { required: false }, "validate.rules": { message: { required: false } } } }
        ]);
    }
    create(value) {
        const message = { permissionship: 0 };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* authzed.api.v1.CheckPermissionResponse.Permissionship permissionship */ 1:
                    message.permissionship = reader.int32();
                    break;
                case /* authzed.api.v1.PartialCaveatInfo partial_caveat_info */ 2:
                    message.partialCaveatInfo = PartialCaveatInfo.internalBinaryRead(reader, reader.uint32(), options, message.partialCaveatInfo);
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* authzed.api.v1.CheckPermissionResponse.Permissionship permissionship = 1; */
        if (message.permissionship !== 0)
            writer.tag(1, WireType.Varint).int32(message.permissionship);
        /* authzed.api.v1.PartialCaveatInfo partial_caveat_info = 2; */
        if (message.partialCaveatInfo)
            PartialCaveatInfo.internalBinaryWrite(message.partialCaveatInfo, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkCheckPermissionResponseItem
 */
export const BulkCheckPermissionResponseItem = new BulkCheckPermissionResponseItem$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkImportRelationshipsRequest$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkImportRelationshipsRequest", [
            { no: 1, name: "relationships", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Relationship, options: { "buf.validate.field": { repeated: { items: { required: true } } }, "validate.rules": { repeated: { items: { message: { required: true } } } } } }
        ]);
    }
    create(value) {
        const message = { relationships: [] };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* repeated authzed.api.v1.Relationship relationships */ 1:
                    message.relationships.push(Relationship.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* repeated authzed.api.v1.Relationship relationships = 1; */
        for (let i = 0; i < message.relationships.length; i++)
            Relationship.internalBinaryWrite(message.relationships[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkImportRelationshipsRequest
 */
export const BulkImportRelationshipsRequest = new BulkImportRelationshipsRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkImportRelationshipsResponse$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkImportRelationshipsResponse", [
            { no: 1, name: "num_loaded", kind: "scalar", T: 4 /*ScalarType.UINT64*/ }
        ]);
    }
    create(value) {
        const message = { numLoaded: "0" };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* uint64 num_loaded */ 1:
                    message.numLoaded = reader.uint64().toString();
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* uint64 num_loaded = 1; */
        if (message.numLoaded !== "0")
            writer.tag(1, WireType.Varint).uint64(message.numLoaded);
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkImportRelationshipsResponse
 */
export const BulkImportRelationshipsResponse = new BulkImportRelationshipsResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkExportRelationshipsRequest$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkExportRelationshipsRequest", [
            { no: 1, name: "consistency", kind: "message", T: () => Consistency },
            { no: 2, name: "optional_limit", kind: "scalar", T: 13 /*ScalarType.UINT32*/, options: { "buf.validate.field": { uint32: { gte: 0 } }, "validate.rules": { uint32: { gte: 0 } } } },
            { no: 3, name: "optional_cursor", kind: "message", T: () => Cursor },
            { no: 4, name: "optional_relationship_filter", kind: "message", T: () => RelationshipFilter }
        ]);
    }
    create(value) {
        const message = { optionalLimit: 0 };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* authzed.api.v1.Consistency consistency */ 1:
                    message.consistency = Consistency.internalBinaryRead(reader, reader.uint32(), options, message.consistency);
                    break;
                case /* uint32 optional_limit */ 2:
                    message.optionalLimit = reader.uint32();
                    break;
                case /* authzed.api.v1.Cursor optional_cursor */ 3:
                    message.optionalCursor = Cursor.internalBinaryRead(reader, reader.uint32(), options, message.optionalCursor);
                    break;
                case /* authzed.api.v1.RelationshipFilter optional_relationship_filter */ 4:
                    message.optionalRelationshipFilter = RelationshipFilter.internalBinaryRead(reader, reader.uint32(), options, message.optionalRelationshipFilter);
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* authzed.api.v1.Consistency consistency = 1; */
        if (message.consistency)
            Consistency.internalBinaryWrite(message.consistency, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* uint32 optional_limit = 2; */
        if (message.optionalLimit !== 0)
            writer.tag(2, WireType.Varint).uint32(message.optionalLimit);
        /* authzed.api.v1.Cursor optional_cursor = 3; */
        if (message.optionalCursor)
            Cursor.internalBinaryWrite(message.optionalCursor, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
        /* authzed.api.v1.RelationshipFilter optional_relationship_filter = 4; */
        if (message.optionalRelationshipFilter)
            RelationshipFilter.internalBinaryWrite(message.optionalRelationshipFilter, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkExportRelationshipsRequest
 */
export const BulkExportRelationshipsRequest = new BulkExportRelationshipsRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class BulkExportRelationshipsResponse$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.BulkExportRelationshipsResponse", [
            { no: 1, name: "after_result_cursor", kind: "message", T: () => Cursor },
            { no: 2, name: "relationships", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => Relationship }
        ]);
    }
    create(value) {
        const message = { relationships: [] };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* authzed.api.v1.Cursor after_result_cursor */ 1:
                    message.afterResultCursor = Cursor.internalBinaryRead(reader, reader.uint32(), options, message.afterResultCursor);
                    break;
                case /* repeated authzed.api.v1.Relationship relationships */ 2:
                    message.relationships.push(Relationship.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* authzed.api.v1.Cursor after_result_cursor = 1; */
        if (message.afterResultCursor)
            Cursor.internalBinaryWrite(message.afterResultCursor, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* repeated authzed.api.v1.Relationship relationships = 2; */
        for (let i = 0; i < message.relationships.length; i++)
            Relationship.internalBinaryWrite(message.relationships[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.BulkExportRelationshipsResponse
 */
export const BulkExportRelationshipsResponse = new BulkExportRelationshipsResponse$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExperimentalReflectSchemaRequest$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ExperimentalReflectSchemaRequest", [
            { no: 1, name: "consistency", kind: "message", T: () => Consistency },
            { no: 2, name: "optional_filters", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ExpSchemaFilter }
        ]);
    }
    create(value) {
        const message = { optionalFilters: [] };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* authzed.api.v1.Consistency consistency */ 1:
                    message.consistency = Consistency.internalBinaryRead(reader, reader.uint32(), options, message.consistency);
                    break;
                case /* repeated authzed.api.v1.ExpSchemaFilter optional_filters */ 2:
                    message.optionalFilters.push(ExpSchemaFilter.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                default:
                    let u = options.readUnknownField;
                    if (u === "throw")
                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
                    let d = reader.skip(wireType);
                    if (u !== false)
                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
            }
        }
        return message;
    }
    internalBinaryWrite(message, writer, options) {
        /* authzed.api.v1.Consistency consistency = 1; */
        if (message.consistency)
            Consistency.internalBinaryWrite(message.consistency, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
        /* repeated authzed.api.v1.ExpSchemaFilter optional_filters = 2; */
        for (let i = 0; i < message.optionalFilters.length; i++)
            ExpSchemaFilter.internalBinaryWrite(message.optionalFilters[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
        let u = options.writeUnknownFields;
        if (u !== false)
            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
        return writer;
    }
}
/**
 * @generated MessageType for protobuf message authzed.api.v1.ExperimentalReflectSchemaRequest
 */
export const ExperimentalReflectSchemaRequest = new ExperimentalReflectSchemaRequest$Type();
// @generated message type with reflection information, may provide speed optimized methods
class ExperimentalReflectSchemaResponse$Type extends MessageType {
    constructor() {
        super("authzed.api.v1.ExperimentalReflectSchemaResponse", [
            { no: 1, name: "definitions", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ExpDefinition },
            { no: 2, name: "caveats", kind: "message", repeat: 1 /*RepeatType.PACKED*/, T: () => ExpCaveat },
            { no: 3, name: "read_at", kind: "message", T: () => ZedToken }
        ]);
    }
    create(value) {
        const message = { definitions: [], caveats: [] };
        globalThis.Object.defineProperty(message, MESSAGE_TYPE, { enumerable: false, value: this });
        if (value !== undefined)
            reflectionMergePartial(this, message, value);
        return message;
    }
    internalBinaryRead(reader, length, options, target) {
        let message = target ?? this.create(), end = reader.pos + length;
        while (reader.pos < end) {
            let [fieldNo, wireType] = reader.tag();
            switch (fieldNo) {
                case /* repeated authzed.api.v1.ExpDefinition definitions */ 1:
                    message.definitions.push(ExpDefinition.internalBinaryRead(reader, reader.uint32(), options));
                    break;
                case