/* eslint-disable */
// This file is automatically generated, do not edit!

/**
 * @module
 * Contains type declarations for Ozone lexicons
 */

import '@atcute/client/lexicons';
import '@atcute/bluesky/lexicons';

declare module '@atcute/client/lexicons' {
	/** Administrative action to create a new, re-usable communication (email for now) template. */
	namespace ToolsOzoneCommunicationCreateTemplate {
		interface Params {}
		interface Input {
			/** Content of the template, markdown supported, can contain variable placeholders. */
			contentMarkdown: string;
			/** Name of the template. */
			name: string;
			/** Subject of the message, used in emails. */
			subject: string;
			/** DID of the user who is creating the template. */
			createdBy?: At.DID;
			/** Message language. */
			lang?: string;
		}
		type Output = ToolsOzoneCommunicationDefs.TemplateView;
		interface Errors {
			DuplicateTemplateName: {};
		}
	}

	namespace ToolsOzoneCommunicationDefs {
		interface TemplateView {
			[Brand.Type]?: 'tools.ozone.communication.defs#templateView';
			/** Subject of the message, used in emails. */
			contentMarkdown: string;
			createdAt: string;
			disabled: boolean;
			id: string;
			/** DID of the user who last updated the template. */
			lastUpdatedBy: At.DID;
			/** Name of the template. */
			name: string;
			updatedAt: string;
			/** Message language. */
			lang?: string;
			/** Content of the template, can contain markdown and variable placeholders. */
			subject?: string;
		}
	}

	/** Delete a communication template. */
	namespace ToolsOzoneCommunicationDeleteTemplate {
		interface Params {}
		interface Input {
			id: string;
		}
		type Output = undefined;
	}

	/** Get list of all communication templates. */
	namespace ToolsOzoneCommunicationListTemplates {
		interface Params {}
		type Input = undefined;
		interface Output {
			communicationTemplates: ToolsOzoneCommunicationDefs.TemplateView[];
		}
	}

	/** Administrative action to update an existing communication template. Allows passing partial fields to patch specific fields only. */
	namespace ToolsOzoneCommunicationUpdateTemplate {
		interface Params {}
		interface Input {
			/** ID of the template to be updated. */
			id: string;
			/** Content of the template, markdown supported, can contain variable placeholders. */
			contentMarkdown?: string;
			disabled?: boolean;
			/** Message language. */
			lang?: string;
			/** Name of the template. */
			name?: string;
			/** Subject of the message, used in emails. */
			subject?: string;
			/** DID of the user who is updating the template. */
			updatedBy?: At.DID;
		}
		type Output = ToolsOzoneCommunicationDefs.TemplateView;
		interface Errors {
			DuplicateTemplateName: {};
		}
	}

	namespace ToolsOzoneModerationDefs {
		/** Logs account status related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
		interface AccountEvent {
			[Brand.Type]?: 'tools.ozone.moderation.defs#accountEvent';
			/** Indicates that the account has a repository which can be fetched from the host that emitted this event. */
			active: boolean;
			timestamp: string;
			comment?: string;
			status?:
				| 'deactivated'
				| 'deleted'
				| 'suspended'
				| 'takendown'
				| 'tombstoned'
				| 'unknown'
				| (string & {});
		}
		interface AccountHosting {
			[Brand.Type]?: 'tools.ozone.moderation.defs#accountHosting';
			status: 'deactivated' | 'deleted' | 'suspended' | 'takendown' | 'unknown' | (string & {});
			createdAt?: string;
			deactivatedAt?: string;
			deletedAt?: string;
			reactivatedAt?: string;
			updatedAt?: string;
		}
		interface BlobView {
			[Brand.Type]?: 'tools.ozone.moderation.defs#blobView';
			cid: At.CID;
			createdAt: string;
			mimeType: string;
			size: number;
			details?: Brand.Union<ImageDetails | VideoDetails>;
			moderation?: Moderation;
		}
		/** Logs identity related events on a repo subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
		interface IdentityEvent {
			[Brand.Type]?: 'tools.ozone.moderation.defs#identityEvent';
			timestamp: string;
			comment?: string;
			handle?: At.Handle;
			pdsHost?: string;
			tombstone?: boolean;
		}
		interface ImageDetails {
			[Brand.Type]?: 'tools.ozone.moderation.defs#imageDetails';
			height: number;
			width: number;
		}
		interface Moderation {
			[Brand.Type]?: 'tools.ozone.moderation.defs#moderation';
			subjectStatus?: SubjectStatusView;
		}
		interface ModerationDetail {
			[Brand.Type]?: 'tools.ozone.moderation.defs#moderationDetail';
			subjectStatus?: SubjectStatusView;
		}
		interface ModEventAcknowledge {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventAcknowledge';
			/** If true, all other reports on content authored by this account will be resolved (acknowledged). */
			acknowledgeAccountSubjects?: boolean;
			comment?: string;
		}
		/** Add a comment to a subject */
		interface ModEventComment {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventComment';
			comment: string;
			/** Make the comment persistent on the subject */
			sticky?: boolean;
		}
		/** Divert a record's blobs to a 3rd party service for further scanning/tagging */
		interface ModEventDivert {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventDivert';
			comment?: string;
		}
		/** Keep a log of outgoing email to a user */
		interface ModEventEmail {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventEmail';
			/** The subject line of the email sent to the user. */
			subjectLine: string;
			/** Additional comment about the outgoing comm. */
			comment?: string;
			/** The content of the email sent to the user. */
			content?: string;
		}
		interface ModEventEscalate {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventEscalate';
			comment?: string;
		}
		/** Apply/Negate labels on a subject */
		interface ModEventLabel {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventLabel';
			createLabelVals: string[];
			negateLabelVals: string[];
			comment?: string;
		}
		/** Mute incoming reports on a subject */
		interface ModEventMute {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventMute';
			/** Indicates how long the subject should remain muted. */
			durationInHours: number;
			comment?: string;
		}
		/** Mute incoming reports from an account */
		interface ModEventMuteReporter {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventMuteReporter';
			comment?: string;
			/** Indicates how long the account should remain muted. Falsy value here means a permanent mute. */
			durationInHours?: number;
		}
		/** Report a subject */
		interface ModEventReport {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventReport';
			reportType: ComAtprotoModerationDefs.ReasonType;
			comment?: string;
			/** Set to true if the reporter was muted from reporting at the time of the event. These reports won't impact the reviewState of the subject. */
			isReporterMuted?: boolean;
		}
		/** Resolve appeal on a subject */
		interface ModEventResolveAppeal {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventResolveAppeal';
			/** Describe resolution. */
			comment?: string;
		}
		/** Revert take down action on a subject */
		interface ModEventReverseTakedown {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventReverseTakedown';
			/** Describe reasoning behind the reversal. */
			comment?: string;
		}
		/** Add/Remove a tag on a subject */
		interface ModEventTag {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventTag';
			/** Tags to be added to the subject. If already exists, won't be duplicated. */
			add: string[];
			/** Tags to be removed to the subject. Ignores a tag If it doesn't exist, won't be duplicated. */
			remove: string[];
			/** Additional comment about added/removed tags. */
			comment?: string;
		}
		/** Take down a subject permanently or temporarily */
		interface ModEventTakedown {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventTakedown';
			/** If true, all other reports on content authored by this account will be resolved (acknowledged). */
			acknowledgeAccountSubjects?: boolean;
			comment?: string;
			/** Indicates how long the takedown should be in effect before automatically expiring. */
			durationInHours?: number;
			/**
			 * Names/Keywords of the policies that drove the decision. \
			 * Maximum array length: 5
			 */
			policies?: string[];
		}
		/** Unmute action on a subject */
		interface ModEventUnmute {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventUnmute';
			/** Describe reasoning behind the reversal. */
			comment?: string;
		}
		/** Unmute incoming reports from an account */
		interface ModEventUnmuteReporter {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventUnmuteReporter';
			/** Describe reasoning behind the reversal. */
			comment?: string;
		}
		interface ModEventView {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventView';
			createdAt: string;
			createdBy: At.DID;
			event: Brand.Union<
				| AccountEvent
				| IdentityEvent
				| ModEventAcknowledge
				| ModEventComment
				| ModEventDivert
				| ModEventEmail
				| ModEventEscalate
				| ModEventLabel
				| ModEventMute
				| ModEventMuteReporter
				| ModEventReport
				| ModEventResolveAppeal
				| ModEventReverseTakedown
				| ModEventTag
				| ModEventTakedown
				| ModEventUnmute
				| ModEventUnmuteReporter
				| RecordEvent
			>;
			id: number;
			subject: Brand.Union<
				ChatBskyConvoDefs.MessageRef | ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main
			>;
			subjectBlobCids: string[];
			creatorHandle?: string;
			subjectHandle?: string;
		}
		interface ModEventViewDetail {
			[Brand.Type]?: 'tools.ozone.moderation.defs#modEventViewDetail';
			createdAt: string;
			createdBy: At.DID;
			event: Brand.Union<
				| AccountEvent
				| IdentityEvent
				| ModEventAcknowledge
				| ModEventComment
				| ModEventDivert
				| ModEventEmail
				| ModEventEscalate
				| ModEventLabel
				| ModEventMute
				| ModEventMuteReporter
				| ModEventReport
				| ModEventResolveAppeal
				| ModEventReverseTakedown
				| ModEventTag
				| ModEventTakedown
				| ModEventUnmute
				| ModEventUnmuteReporter
				| RecordEvent
			>;
			id: number;
			subject: Brand.Union<RecordView | RecordViewNotFound | RepoView | RepoViewNotFound>;
			subjectBlobs: BlobView[];
		}
		/** Logs lifecycle event on a record subject. Normally captured by automod from the firehose and emitted to ozone for historical tracking. */
		interface RecordEvent {
			[Brand.Type]?: 'tools.ozone.moderation.defs#recordEvent';
			op: 'create' | 'delete' | 'update' | (string & {});
			timestamp: string;
			cid?: At.CID;
			comment?: string;
		}
		interface RecordHosting {
			[Brand.Type]?: 'tools.ozone.moderation.defs#recordHosting';
			status: 'deleted' | 'unknown' | (string & {});
			createdAt?: string;
			deletedAt?: string;
			updatedAt?: string;
		}
		interface RecordView {
			[Brand.Type]?: 'tools.ozone.moderation.defs#recordView';
			blobCids: At.CID[];
			cid: At.CID;
			indexedAt: string;
			moderation: Moderation;
			repo: RepoView;
			uri: At.Uri;
			value: unknown;
		}
		interface RecordViewDetail {
			[Brand.Type]?: 'tools.ozone.moderation.defs#recordViewDetail';
			blobs: BlobView[];
			cid: At.CID;
			indexedAt: string;
			moderation: ModerationDetail;
			repo: RepoView;
			uri: At.Uri;
			value: unknown;
			labels?: ComAtprotoLabelDefs.Label[];
		}
		interface RecordViewNotFound {
			[Brand.Type]?: 'tools.ozone.moderation.defs#recordViewNotFound';
			uri: At.Uri;
		}
		interface RepoView {
			[Brand.Type]?: 'tools.ozone.moderation.defs#repoView';
			did: At.DID;
			handle: At.Handle;
			indexedAt: string;
			moderation: Moderation;
			relatedRecords: unknown[];
			deactivatedAt?: string;
			email?: string;
			invitedBy?: ComAtprotoServerDefs.InviteCode;
			inviteNote?: string;
			invitesDisabled?: boolean;
			threatSignatures?: ComAtprotoAdminDefs.ThreatSignature[];
		}
		interface RepoViewDetail {
			[Brand.Type]?: 'tools.ozone.moderation.defs#repoViewDetail';
			did: At.DID;
			handle: At.Handle;
			indexedAt: string;
			moderation: ModerationDetail;
			relatedRecords: unknown[];
			deactivatedAt?: string;
			email?: string;
			emailConfirmedAt?: string;
			invitedBy?: ComAtprotoServerDefs.InviteCode;
			inviteNote?: string;
			invites?: ComAtprotoServerDefs.InviteCode[];
			invitesDisabled?: boolean;
			labels?: ComAtprotoLabelDefs.Label[];
			threatSignatures?: ComAtprotoAdminDefs.ThreatSignature[];
		}
		interface RepoViewNotFound {
			[Brand.Type]?: 'tools.ozone.moderation.defs#repoViewNotFound';
			did: At.DID;
		}
		type ReviewClosed = 'tools.ozone.moderation.defs#reviewClosed';
		type ReviewEscalated = 'tools.ozone.moderation.defs#reviewEscalated';
		type ReviewNone = 'tools.ozone.moderation.defs#reviewNone';
		type ReviewOpen = 'tools.ozone.moderation.defs#reviewOpen';
		type SubjectReviewState =
			| '#reviewClosed'
			| '#reviewEscalated'
			| '#reviewNone'
			| '#reviewOpen'
			| (string & {});
		interface SubjectStatusView {
			[Brand.Type]?: 'tools.ozone.moderation.defs#subjectStatusView';
			/** Timestamp referencing the first moderation status impacting event was emitted on the subject */
			createdAt: string;
			id: number;
			reviewState: SubjectReviewState;
			subject: Brand.Union<ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main>;
			/** Timestamp referencing when the last update was made to the moderation status of the subject */
			updatedAt: string;
			/** True indicates that the a previously taken moderator action was appealed against, by the author of the content. False indicates last appeal was resolved by moderators. */
			appealed?: boolean;
			/** Sticky comment on the subject. */
			comment?: string;
			hosting?: Brand.Union<AccountHosting | RecordHosting>;
			/** Timestamp referencing when the author of the subject appealed a moderation action */
			lastAppealedAt?: string;
			lastReportedAt?: string;
			lastReviewedAt?: string;
			lastReviewedBy?: At.DID;
			muteReportingUntil?: string;
			muteUntil?: string;
			subjectBlobCids?: At.CID[];
			subjectRepoHandle?: string;
			suspendUntil?: string;
			tags?: string[];
			takendown?: boolean;
		}
		interface VideoDetails {
			[Brand.Type]?: 'tools.ozone.moderation.defs#videoDetails';
			height: number;
			length: number;
			width: number;
		}
	}

	/** Take a moderation action on an actor. */
	namespace ToolsOzoneModerationEmitEvent {
		interface Params {}
		interface Input {
			createdBy: At.DID;
			event: Brand.Union<
				| ToolsOzoneModerationDefs.AccountEvent
				| ToolsOzoneModerationDefs.IdentityEvent
				| ToolsOzoneModerationDefs.ModEventAcknowledge
				| ToolsOzoneModerationDefs.ModEventComment
				| ToolsOzoneModerationDefs.ModEventEmail
				| ToolsOzoneModerationDefs.ModEventEscalate
				| ToolsOzoneModerationDefs.ModEventLabel
				| ToolsOzoneModerationDefs.ModEventMute
				| ToolsOzoneModerationDefs.ModEventMuteReporter
				| ToolsOzoneModerationDefs.ModEventReport
				| ToolsOzoneModerationDefs.ModEventResolveAppeal
				| ToolsOzoneModerationDefs.ModEventReverseTakedown
				| ToolsOzoneModerationDefs.ModEventTag
				| ToolsOzoneModerationDefs.ModEventTakedown
				| ToolsOzoneModerationDefs.ModEventUnmute
				| ToolsOzoneModerationDefs.ModEventUnmuteReporter
				| ToolsOzoneModerationDefs.RecordEvent
			>;
			subject: Brand.Union<ComAtprotoAdminDefs.RepoRef | ComAtprotoRepoStrongRef.Main>;
			subjectBlobCids?: At.CID[];
		}
		type Output = ToolsOzoneModerationDefs.ModEventView;
		interface Errors {
			SubjectHasAction: {};
		}
	}

	/** Get details about a moderation event. */
	namespace ToolsOzoneModerationGetEvent {
		interface Params {
			id: number;
		}
		type Input = undefined;
		type Output = ToolsOzoneModerationDefs.ModEventViewDetail;
	}

	/** Get details about a record. */
	namespace ToolsOzoneModerationGetRecord {
		interface Params {
			uri: At.Uri;
			cid?: At.CID;
		}
		type Input = undefined;
		type Output = ToolsOzoneModerationDefs.RecordViewDetail;
		interface Errors {
			RecordNotFound: {};
		}
	}

	/** Get details about some records. */
	namespace ToolsOzoneModerationGetRecords {
		interface Params {
			/** Maximum array length: 100 */
			uris: At.Uri[];
		}
		type Input = undefined;
		interface Output {
			records: Brand.Union<
				ToolsOzoneModerationDefs.RecordViewDetail | ToolsOzoneModerationDefs.RecordViewNotFound
			>[];
		}
	}

	/** Get details about a repository. */
	namespace ToolsOzoneModerationGetRepo {
		interface Params {
			did: At.DID;
		}
		type Input = undefined;
		type Output = ToolsOzoneModerationDefs.RepoViewDetail;
		interface Errors {
			RepoNotFound: {};
		}
	}

	/** Get details about some repositories. */
	namespace ToolsOzoneModerationGetRepos {
		interface Params {
			/** Maximum array length: 100 */
			dids: At.DID[];
		}
		type Input = undefined;
		interface Output {
			repos: Brand.Union<
				ToolsOzoneModerationDefs.RepoViewDetail | ToolsOzoneModerationDefs.RepoViewNotFound
			>[];
		}
	}

	/** List moderation events related to a subject. */
	namespace ToolsOzoneModerationQueryEvents {
		interface Params {
			/** If specified, only events where all of these labels were added are returned */
			addedLabels?: string[];
			/** If specified, only events where all of these tags were added are returned */
			addedTags?: string[];
			/**
			 * If specified, only events where the subject belongs to the given collections will be returned. When subjectType is set to 'account', this will be ignored. \
			 * Maximum array length: 20
			 */
			collections?: string[];
			/** If specified, only events with comments containing the keyword are returned. Apply || separator to use multiple keywords and match using OR condition. */
			comment?: string;
			/** Retrieve events created after a given timestamp */
			createdAfter?: string;
			/** Retrieve events created before a given timestamp */
			createdBefore?: string;
			createdBy?: At.DID;
			cursor?: string;
			/** If true, only events with comments are returned */
			hasComment?: boolean;
			/**
			 * If true, events on all record types (posts, lists, profile etc.) or records from given 'collections' param, owned by the did are returned.
			 * @default false
			 */
			includeAllUserRecords?: boolean;
			/**
			 * Minimum: 1 \
			 * Maximum: 100
			 * @default 50
			 */
			limit?: number;
			/** If specified, only events where the action policies match any of the given policies are returned */
			policies?: string[];
			/** If specified, only events where all of these labels were removed are returned */
			removedLabels?: string[];
			/** If specified, only events where all of these tags were removed are returned */
			removedTags?: string[];
			reportTypes?: string[];
			/**
			 * Sort direction for the events. Defaults to descending order of created at timestamp.
			 * @default "desc"
			 */
			sortDirection?: 'asc' | 'desc';
			subject?: string;
			/** If specified, only events where the subject is of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored. */
			subjectType?: 'account' | 'record' | (string & {});
			/** The types of events (fully qualified string in the format of tools.ozone.moderation.defs#modEvent<name>) to filter by. If not specified, all events are returned. */
			types?: string[];
		}
		type Input = undefined;
		interface Output {
			events: ToolsOzoneModerationDefs.ModEventView[];
			cursor?: string;
		}
	}

	/** View moderation statuses of subjects (record or repo). */
	namespace ToolsOzoneModerationQueryStatuses {
		interface Params {
			/** Get subjects in unresolved appealed status */
			appealed?: boolean;
			/**
			 * If specified, subjects belonging to the given collections will be returned. When subjectType is set to 'account', this will be ignored. \
			 * Maximum array length: 20
			 */
			collections?: string[];
			/** Search subjects by keyword from comments */
			comment?: string;
			cursor?: string;
			excludeTags?: string[];
			/** Search subjects where the associated record/account was deleted after a given timestamp */
			hostingDeletedAfter?: string;
			/** Search subjects where the associated record/account was deleted before a given timestamp */
			hostingDeletedBefore?: string;
			/** Search subjects by the status of the associated record/account */
			hostingStatuses?: string[];
			/** Search subjects where the associated record/account was updated after a given timestamp */
			hostingUpdatedAfter?: string;
			/** Search subjects where the associated record/account was updated before a given timestamp */
			hostingUpdatedBefore?: string;
			ignoreSubjects?: string[];
			/** All subjects, or subjects from given 'collections' param, belonging to the account specified in the 'subject' param will be returned. */
			includeAllUserRecords?: boolean;
			/** By default, we don't include muted subjects in the results. Set this to true to include them. */
			includeMuted?: boolean;
			/** Get all subject statuses that were reviewed by a specific moderator */
			lastReviewedBy?: At.DID;
			/**
			 * Minimum: 1 \
			 * Maximum: 100
			 * @default 50
			 */
			limit?: number;
			/** When set to true, only muted subjects and reporters will be returned. */
			onlyMuted?: boolean;
			/** Number of queues being used by moderators. Subjects will be split among all queues. */
			queueCount?: number;
			/** Index of the queue to fetch subjects from. Works only when queueCount value is specified. */
			queueIndex?: number;
			/** A seeder to shuffle/balance the queue items. */
			queueSeed?: string;
			/** Search subjects reported after a given timestamp */
			reportedAfter?: string;
			/** Search subjects reported before a given timestamp */
			reportedBefore?: string;
			/** Search subjects reviewed after a given timestamp */
			reviewedAfter?: string;
			/** Search subjects reviewed before a given timestamp */
			reviewedBefore?: string;
			/** Specify when fetching subjects in a certain state */
			reviewState?: string;
			/** @default "desc" */
			sortDirection?: 'asc' | 'desc';
			/** @default "lastReportedAt" */
			sortField?: 'lastReviewedAt' | 'lastReportedAt';
			/** The subject to get the status for. */
			subject?: string;
			/** If specified, subjects of the given type (account or record) will be returned. When this is set to 'account' the 'collections' parameter will be ignored. When includeAllUserRecords or subject is set, this will be ignored. */
			subjectType?: 'account' | 'record' | (string & {});
			/**
			 * Maximum array length: 25 \
			 * Items in this array are applied with OR filters. To apply AND filter, put all tags in the same string and separate using && characters
			 */
			tags?: string[];
			/** Get subjects that were taken down */
			takendown?: boolean;
		}
		type Input = undefined;
		interface Output {
			subjectStatuses: ToolsOzoneModerationDefs.SubjectStatusView[];
			cursor?: string;
		}
	}

	/** Find repositories based on a search term. */
	namespace ToolsOzoneModerationSearchRepos {
		interface Params {
			cursor?: string;
			/**
			 * Minimum: 1 \
			 * Maximum: 100
			 * @default 50
			 */
			limit?: number;
			q?: string;
			/**
			 * DEPRECATED: use 'q' instead
			 * @deprecated
			 */
			term?: string;
		}
		type Input = undefined;
		interface Output {
			repos: ToolsOzoneModerationDefs.RepoView[];
			cursor?: string;
		}
	}

	/** Get details about ozone's server configuration. */
	namespace ToolsOzoneServerGetConfig {
		interface Params {}
		type Input = undefined;
		interface Output {
			appview?: ServiceConfig;
			blobDivert?: ServiceConfig;
			chat?: ServiceConfig;
			pds?: ServiceConfig;
			viewer?: ViewerConfig;
		}
		interface ServiceConfig {
			[Brand.Type]?: 'tools.ozone.server.getConfig#serviceConfig';
			url?: string;
		}
		interface ViewerConfig {
			[Brand.Type]?: 'tools.ozone.server.getConfig#viewerConfig';
			role?:
				| 'tools.ozone.team.defs#roleAdmin'
				| 'tools.ozone.team.defs#roleModerator'
				| 'tools.ozone.team.defs#roleTriage'
				| (string & {});
		}
	}

	/** Add values to a specific set. Attempting to add values to a set that does not exist will result in an error. */
	namespace ToolsOzoneSetAddValues {
		interface Params {}
		interface Input {
			/** Name of the set to add values to */
			name: string;
			/**
			 * Array of string values to add to the set \
			 * Minimum array length: 1 \
			 * Maximum array length: 1000
			 */
			values: string[];
		}
		type Output = undefined;
	}

	namespace ToolsOzoneSetDefs {
		interface Set {
			[Brand.Type]?: 'tools.ozone.set.defs#set';
			/**
			 * Minimum string length: 3 \
			 * Maximum string length: 128
			 */
			name: string;
			/**
			 * Maximum string length: 10240 \
			 * Maximum grapheme length: 1024
			 */
			description?: string;
		}
		interface SetView {
			[Brand.Type]?: 'tools.ozone.set.defs#setView';
			createdAt: string;
			/**
			 * Minimum string length: 3 \
			 * Maximum string length: 128
			 */
			name: string;
			setSize: number;
			updatedAt: string;
			/**
			 * Maximum string length: 10240 \
			 * Maximum grapheme length: 1024
			 */
			description?: string;
		}
	}

	/** Delete an entire set. Attempting to delete a set that does not exist will result in an error. */
	namespace ToolsOzoneSetDeleteSet {
		interface Params {}
		interface Input {
			/** Name of the set to delete */
			name: string;
		}
		interface Output {}
		interface Errors {
			SetNotFound: {};
		}
	}

	/** Delete values from a specific set. Attempting to delete values that are not in the set will not result in an error */
	namespace ToolsOzoneSetDeleteValues {
		interface Params {}
		interface Input {
			/** Name of the set to delete values from */
			name: string;
			/**
			 * Array of string values to delete from the set \
			 * Minimum array length: 1
			 */
			values: string[];
		}
		type Output = undefined;
		interface Errors {
			SetNotFound: {};
		}
	}

	/** Get a specific set and its values */
	namespace ToolsOzoneSetGetValues {
		interface Params {
			name: string;
			cursor?: string;
			/**
			 * Minimum: 1 \
			 * Maximum: 1000
			 * @default 100
			 */
			limit?: number;
		}
		type Input = undefined;
		interface Output {
			set: ToolsOzoneSetDefs.SetView;
			values: string[];
			cursor?: string;
		}
		interface Errors {
			SetNotFound: {};
		}
	}

	/** Query available sets */
	namespace ToolsOzoneSetQuerySets {
		interface Params {
			cursor?: string;
			/**
			 * Minimum: 1 \
			 * Maximum: 100
			 * @default 50
			 */
			limit?: number;
			namePrefix?: string;
			/** @default "name" */
			sortBy?: 'name' | 'createdAt' | 'updatedAt';
			/**
			 * Defaults to ascending order of name field.
			 * @default "asc"
			 */
			sortDirection?: 'asc' | 'desc';
		}
		type Input = undefined;
		interface Output {
			sets: ToolsOzoneSetDefs.SetView[];
			cursor?: string;
		}
	}

	/** Create or update set metadata */
	namespace ToolsOzoneSetUpsertSet {
		interface Params {}
		type Input = ToolsOzoneSetDefs.Set;
		type Output = ToolsOzoneSetDefs.SetView;
	}

	namespace ToolsOzoneSettingDefs {
		interface Option {
			[Brand.Type]?: 'tools.ozone.setting.defs#option';
			createdBy: At.DID;
			did: At.DID;
			key: string;
			lastUpdatedBy: At.DID;
			scope: 'instance' | 'personal' | (string & {});
			value: unknown;
			createdAt?: string;
			/**
			 * Maximum string length: 10240 \
			 * Maximum grapheme length: 1024
			 */
			description?: string;
			managerRole?:
				| 'tools.ozone.team.defs#roleAdmin'
				| 'tools.ozone.team.defs#roleModerator'
				| 'tools.ozone.team.defs#roleTriage'
				| (string & {});
			updatedAt?: string;
		}
	}

	/** List settings with optional filtering */
	namespace ToolsOzoneSettingListOptions {
		interface Params {
			cursor?: string;
			/**
			 * Filter for only the specified keys. Ignored if prefix is provided \
			 * Maximum array length: 100
			 */
			keys?: string[];
			/**
			 * Minimum: 1 \
			 * Maximum: 100
			 * @default 50
			 */
			limit?: number;
			/** Filter keys by prefix */
			prefix?: string;
			/** @default "instance" */
			scope?: 'instance' | 'personal' | (string & {});
		}
		type Input = undefined;
		interface Output {
			options: ToolsOzoneSettingDefs.Option[];
			cursor?: string;
		}
	}

	/** Delete settings by key */
	namespace ToolsOzoneSettingRemoveOptions {
		interface Params {}
		interface Input {
			/**
			 * Minimum array length: 1 \
			 * Maximum array length: 200
			 */
			keys: string[];
			scope: 'instance' | 'personal' | (string & {});
		}
		interface Output {}
	}

	/** Create or update setting option */
	namespace ToolsOzoneSettingUpsertOption {
		interface Params {}
		interface Input {
			key: string;
			scope: 'instance' | 'personal' | (string & {});
			value: unknown;
			/** Maximum string length: 2000 */
			description?: string;
			managerRole?:
				| 'tools.ozone.team.defs#roleAdmin'
				| 'tools.ozone.team.defs#roleModerator'
				| 'tools.ozone.team.defs#roleTriage'
				| (string & {});
		}
		interface Output {
			option: ToolsOzoneSettingDefs.Option;
		}
	}

	namespace ToolsOzoneSignatureDefs {
		interface SigDetail {
			[Brand.Type]?: 'tools.ozone.signature.defs#sigDetail';
			property: string;
			value: string;
		}
	}

	/** Find all correlated threat signatures between 2 or more accounts. */
	namespace ToolsOzoneSignatureFindCorrelation {
		interface Params {
			dids: At.DID[];
		}
		type Input = undefined;
		interface Output {
			details: ToolsOzoneSignatureDefs.SigDetail[];
		}
	}

	/** Get accounts that share some matching threat signatures with the root account. */
	namespace ToolsOzoneSignatureFindRelatedAccounts {
		interface Params {
			did: At.DID;
			cursor?: string;
			/**
			 * Minimum: 1 \
			 * Maximum: 100
			 * @default 50
			 */
			limit?: number;
		}
		type Input = undefined;
		interface Output {
			accounts: RelatedAccount[];
			cursor?: string;
		}
		interface RelatedAccount {
			[Brand.Type]?: 'tools.ozone.signature.findRelatedAccounts#relatedAccount';
			account: ComAtprotoAdminDefs.AccountView;
			similarities?: ToolsOzoneSignatureDefs.SigDetail[];
		}
	}

	/** Search for accounts that match one or more threat signature values. */
	namespace ToolsOzoneSignatureSearchAccounts {
		interface Params {
			values: string[];
			cursor?: string;
			/**
			 * Minimum: 1 \
			 * Maximum: 100
			 * @default 50
			 */
			limit?: number;
		}
		type Input = undefined;
		interface Output {
			accounts: ComAtprotoAdminDefs.AccountView[];
			cursor?: string;
		}
	}

	/** Add a member to the ozone team. Requires admin role. */
	namespace ToolsOzoneTeamAddMember {
		interface Params {}
		interface Input {
			did: At.DID;
			role:
				| 'tools.ozone.team.defs#roleAdmin'
				| 'tools.ozone.team.defs#roleModerator'
				| 'tools.ozone.team.defs#roleTriage'
				| (string & {});
		}
		type Output = ToolsOzoneTeamDefs.Member;
		interface Errors {
			MemberAlreadyExists: {};
		}
	}

	namespace ToolsOzoneTeamDefs {
		interface Member {
			[Brand.Type]?: 'tools.ozone.team.defs#member';
			did: At.DID;
			role: '#roleAdmin' | '#roleModerator' | '#roleTriage' | (string & {});
			createdAt?: string;
			disabled?: boolean;
			lastUpdatedBy?: string;
			profile?: AppBskyActorDefs.ProfileViewDetailed;
			updatedAt?: string;
		}
		type RoleAdmin = 'tools.ozone.team.defs#roleAdmin';
		type RoleModerator = 'tools.ozone.team.defs#roleModerator';
		type RoleTriage = 'tools.ozone.team.defs#roleTriage';
	}

	/** Delete a member from ozone team. Requires admin role. */
	namespace ToolsOzoneTeamDeleteMember {
		interface Params {}
		interface Input {
			did: At.DID;
		}
		type Output = undefined;
		interface Errors {
			MemberNotFound: {};
			CannotDeleteSelf: {};
		}
	}

	/** List all members with access to the ozone service. */
	namespace ToolsOzoneTeamListMembers {
		interface Params {
			cursor?: string;
			/**
			 * Minimum: 1 \
			 * Maximum: 100
			 * @default 50
			 */
			limit?: number;
		}
		type Input = undefined;
		interface Output {
			members: ToolsOzoneTeamDefs.Member[];
			cursor?: string;
		}
	}

	/** Update a member in the ozone service. Requires admin role. */
	namespace ToolsOzoneTeamUpdateMember {
		interface Params {}
		interface Input {
			did: At.DID;
			disabled?: boolean;
			role?:
				| 'tools.ozone.team.defs#roleAdmin'
				| 'tools.ozone.team.defs#roleModerator'
				| 'tools.ozone.team.defs#roleTriage'
				| (string & {});
		}
		type Output = ToolsOzoneTeamDefs.Member;
		interface Errors {
			MemberNotFound: {};
		}
	}

	interface Records {}

	interface Queries {
		'tools.ozone.communication.listTemplates': {
			output: ToolsOzoneCommunicationListTemplates.Output;
		};
		'tools.ozone.moderation.getEvent': {
			params: ToolsOzoneModerationGetEvent.Params;
			output: ToolsOzoneModerationGetEvent.Output;
		};
		'tools.ozone.moderation.getRecord': {
			params: ToolsOzoneModerationGetRecord.Params;
			output: ToolsOzoneModerationGetRecord.Output;
		};
		'tools.ozone.moderation.getRecords': {
			params: ToolsOzoneModerationGetRecords.Params;
			output: ToolsOzoneModerationGetRecords.Output;
		};
		'tools.ozone.moderation.getRepo': {
			params: ToolsOzoneModerationGetRepo.Params;
			output: ToolsOzoneModerationGetRepo.Output;
		};
		'tools.ozone.moderation.getRepos': {
			params: ToolsOzoneModerationGetRepos.Params;
			output: ToolsOzoneModerationGetRepos.Output;
		};
		'tools.ozone.moderation.queryEvents': {
			params: ToolsOzoneModerationQueryEvents.Params;
			output: ToolsOzoneModerationQueryEvents.Output;
		};
		'tools.ozone.moderation.queryStatuses': {
			params: ToolsOzoneModerationQueryStatuses.Params;
			output: ToolsOzoneModerationQueryStatuses.Output;
		};
		'tools.ozone.moderation.searchRepos': {
			params: ToolsOzoneModerationSearchRepos.Params;
			output: ToolsOzoneModerationSearchRepos.Output;
		};
		'tools.ozone.server.getConfig': {
			output: ToolsOzoneServerGetConfig.Output;
		};
		'tools.ozone.set.getValues': {
			params: ToolsOzoneSetGetValues.Params;
			output: ToolsOzoneSetGetValues.Output;
		};
		'tools.ozone.set.querySets': {
			params: ToolsOzoneSetQuerySets.Params;
			output: ToolsOzoneSetQuerySets.Output;
		};
		'tools.ozone.setting.listOptions': {
			params: ToolsOzoneSettingListOptions.Params;
			output: ToolsOzoneSettingListOptions.Output;
		};
		'tools.ozone.signature.findCorrelation': {
			params: ToolsOzoneSignatureFindCorrelation.Params;
			output: ToolsOzoneSignatureFindCorrelation.Output;
		};
		'tools.ozone.signature.findRelatedAccounts': {
			params: ToolsOzoneSignatureFindRelatedAccounts.Params;
			output: ToolsOzoneSignatureFindRelatedAccounts.Output;
		};
		'tools.ozone.signature.searchAccounts': {
			params: ToolsOzoneSignatureSearchAccounts.Params;
			output: ToolsOzoneSignatureSearchAccounts.Output;
		};
		'tools.ozone.team.listMembers': {
			params: ToolsOzoneTeamListMembers.Params;
			output: ToolsOzoneTeamListMembers.Output;
		};
	}

	interface Procedures {
		'tools.ozone.communication.createTemplate': {
			input: ToolsOzoneCommunicationCreateTemplate.Input;
			output: ToolsOzoneCommunicationCreateTemplate.Output;
		};
		'tools.ozone.communication.deleteTemplate': {
			input: ToolsOzoneCommunicationDeleteTemplate.Input;
		};
		'tools.ozone.communication.updateTemplate': {
			input: ToolsOzoneCommunicationUpdateTemplate.Input;
			output: ToolsOzoneCommunicationUpdateTemplate.Output;
		};
		'tools.ozone.moderation.emitEvent': {
			input: ToolsOzoneModerationEmitEvent.Input;
			output: ToolsOzoneModerationEmitEvent.Output;
		};
		'tools.ozone.set.addValues': {
			input: ToolsOzoneSetAddValues.Input;
		};
		'tools.ozone.set.deleteSet': {
			input: ToolsOzoneSetDeleteSet.Input;
			output: ToolsOzoneSetDeleteSet.Output;
		};
		'tools.ozone.set.deleteValues': {
			input: ToolsOzoneSetDeleteValues.Input;
		};
		'tools.ozone.set.upsertSet': {
			input: ToolsOzoneSetUpsertSet.Input;
			output: ToolsOzoneSetUpsertSet.Output;
		};
		'tools.ozone.setting.removeOptions': {
			input: ToolsOzoneSettingRemoveOptions.Input;
			output: ToolsOzoneSettingRemoveOptions.Output;
		};
		'tools.ozone.setting.upsertOption': {
			input: ToolsOzoneSettingUpsertOption.Input;
			output: ToolsOzoneSettingUpsertOption.Output;
		};
		'tools.ozone.team.addMember': {
			input: ToolsOzoneTeamAddMember.Input;
			output: ToolsOzoneTeamAddMember.Output;
		};
		'tools.ozone.team.deleteMember': {
			input: ToolsOzoneTeamDeleteMember.Input;
		};
		'tools.ozone.team.updateMember': {
			input: ToolsOzoneTeamUpdateMember.Input;
			output: ToolsOzoneTeamUpdateMember.Output;
		};
	}
}