import { TailorEnv, TailorPrincipal } from "../../../../runtime/types.mjs";
import { SerializeDates, output } from "../../../../types/helpers.mjs";
import { AuthAccessTokenTrigger as AuthAccessTokenTrigger$1, IdpUserTrigger as IdpUserTrigger$1, ResolverExecutedTrigger as ResolverExecutedTrigger$1, TailorDBTrigger as TailorDBTrigger$1, WorkflowExecutionTrigger as WorkflowExecutionTrigger$1, WorkflowJobExecutionTrigger as WorkflowJobExecutionTrigger$1 } from "../../../../types/executor.generated.mjs";
import { TailorDBType } from "../../tailordb/schema.mjs";
import { IdpName } from "../../../types/idp-name.mjs";
import { ResolverConfig } from "../../resolver/resolver.mjs";
import { Workflow } from "../../workflow/workflow.mjs";
//#region src/configure/services/executor/trigger/event.d.ts
interface EventArgs {
  workspaceId: string;
  appNamespace: string;
  env: TailorEnv;
  actor: TailorPrincipal | null;
}
interface RecordArgs extends EventArgs {
  typeName: string;
}
export interface RecordCreatedArgs<T extends TailorDBType> extends RecordArgs {
  event: "created";
  rawEvent: "tailordb.type_record.created";
  newRecord: output<T>;
}
export interface RecordUpdatedArgs<T extends TailorDBType> extends RecordArgs {
  event: "updated";
  rawEvent: "tailordb.type_record.updated";
  newRecord: output<T>;
  oldRecord: output<T>;
}
export interface RecordDeletedArgs<T extends TailorDBType> extends RecordArgs {
  event: "deleted";
  rawEvent: "tailordb.type_record.deleted";
  oldRecord: output<T>;
}
/**
 * Args for resolverExecutedTrigger. This is a discriminated union on `success`.
 *
 * When `success` is true, `result` contains the resolver output and `error` is never.
 * When `success` is false, `error` contains the error message and `result` is never.
 *
 * Narrow on `success` to safely access either `result` or `error`.
 *
 * The event payload arrives as JSON, so a `t.date({ as: "date" })` field in the
 * resolver's output reaches `result` as its serialized `YYYY-MM-DD` string.
 * @example
 * body: async (args) => {
 *   if (args.success) {
 *     console.log(args.result);
 *   } else {
 *     console.error(args.error);
 *   }
 * }
 */
export type ResolverExecutedArgs<R extends ResolverConfig> = EventArgs & {
  resolverName: string;
} & ({
  success: true;
  result: SerializeDates<output<R["output"]>>;
  error?: never;
} | {
  success: false;
  result?: never;
  error: string;
});
export interface IdpUserCreatedArgs extends EventArgs {
  event: "created";
  rawEvent: "idp.user.created";
  namespaceName: string;
  userId: string;
}
export interface IdpUserUpdatedArgs extends EventArgs {
  event: "updated";
  rawEvent: "idp.user.updated";
  namespaceName: string;
  userId: string;
}
export interface IdpUserDeletedArgs extends EventArgs {
  event: "deleted";
  rawEvent: "idp.user.deleted";
  namespaceName: string;
  userId: string;
}
export type IdpUserArgs = IdpUserCreatedArgs | IdpUserUpdatedArgs | IdpUserDeletedArgs;
export interface AuthAccessTokenIssuedArgs extends EventArgs {
  event: "issued";
  rawEvent: "auth.access_token.issued";
  namespaceName: string;
  userId: string;
}
export interface AuthAccessTokenRefreshedArgs extends EventArgs {
  event: "refreshed";
  rawEvent: "auth.access_token.refreshed";
  namespaceName: string;
  userId: string;
}
export interface AuthAccessTokenRevokedArgs extends EventArgs {
  event: "revoked";
  rawEvent: "auth.access_token.revoked";
  namespaceName: string;
  userId: string;
}
export type AuthAccessTokenArgs = AuthAccessTokenIssuedArgs | AuthAccessTokenRefreshedArgs | AuthAccessTokenRevokedArgs;
interface WorkflowExecutionEventArgs {
  workspaceId: string;
  env: TailorEnv;
  actor: TailorPrincipal | null;
  workflowId: string;
  workflowName: string;
  workflowExecutionId: string;
}
/**
 * Discriminated union on `success` shared by the `completed` events of both
 * granularity levels.
 *
 * When `success` is false, `error` carries the failure message; narrow on
 * `success` before accessing it.
 */
type CompletedResult = {
  success: true;
  error?: never;
} | {
  success: false;
  error: string;
};
export interface WorkflowExecutionStartedArgs extends WorkflowExecutionEventArgs {
  event: "started";
  rawEvent: "workflow.workflow_execution.started";
}
export type WorkflowExecutionCompletedArgs = WorkflowExecutionEventArgs & {
  event: "completed";
  rawEvent: "workflow.workflow_execution.completed";
} & CompletedResult;
export interface WorkflowExecutionRetriedArgs extends WorkflowExecutionEventArgs {
  event: "retried";
  rawEvent: "workflow.workflow_execution.retried";
  /** Number of retries already attempted for this execution. */
  retryCount: number;
  /** RFC 3339 timestamp the retry is scheduled for. */
  retryAfter: string;
}
export interface WorkflowExecutionResumedArgs extends WorkflowExecutionEventArgs {
  event: "resumed";
  rawEvent: "workflow.workflow_execution.resumed";
}
export interface WorkflowExecutionWaitStartedArgs extends WorkflowExecutionEventArgs {
  event: "wait_started";
  rawEvent: "workflow.workflow_execution.wait_started";
}
export interface WorkflowExecutionWaitResolvedArgs extends WorkflowExecutionEventArgs {
  event: "wait_resolved";
  rawEvent: "workflow.workflow_execution.wait_resolved";
}
export type WorkflowExecutionArgs = WorkflowExecutionStartedArgs | WorkflowExecutionCompletedArgs | WorkflowExecutionRetriedArgs | WorkflowExecutionResumedArgs | WorkflowExecutionWaitStartedArgs | WorkflowExecutionWaitResolvedArgs;
interface WorkflowJobExecutionEventArgs extends WorkflowExecutionEventArgs {
  workflowJobExecutionId: string;
  /** Name of the job, as passed to `createWorkflowJob({ name })`. */
  jobFunctionName: string;
}
export interface WorkflowJobExecutionStartedArgs extends WorkflowJobExecutionEventArgs {
  event: "started";
  rawEvent: "workflow.workflow_execution.job_execution.started";
}
export type WorkflowJobExecutionCompletedArgs = WorkflowJobExecutionEventArgs & {
  event: "completed";
  rawEvent: "workflow.workflow_execution.job_execution.completed";
} & CompletedResult;
export interface WorkflowJobExecutionWaitStartedArgs extends WorkflowJobExecutionEventArgs {
  event: "wait_started";
  rawEvent: "workflow.workflow_execution.job_execution.wait_started";
  /** Wait point key the job is suspended on. */
  waitKey: string;
  /** JSON-serialized payload recorded with the wait point, absent when none was recorded. */
  waitPayload?: string;
}
export interface WorkflowJobExecutionWaitResolvedArgs extends WorkflowJobExecutionEventArgs {
  event: "wait_resolved";
  rawEvent: "workflow.workflow_execution.job_execution.wait_resolved";
  /** Wait point key that was resolved. */
  waitKey: string;
}
export type WorkflowJobExecutionArgs = WorkflowJobExecutionStartedArgs | WorkflowJobExecutionCompletedArgs | WorkflowJobExecutionWaitStartedArgs | WorkflowJobExecutionWaitResolvedArgs;
declare const recordEventMap: {
  readonly created: "tailordb.type_record.created";
  readonly updated: "tailordb.type_record.updated";
  readonly deleted: "tailordb.type_record.deleted";
};
type RecordEventMap = typeof recordEventMap;
type RecordEventKind = keyof RecordEventMap;
type RecordArgsMap<T extends TailorDBType> = {
  created: RecordCreatedArgs<T>;
  updated: RecordUpdatedArgs<T>;
  deleted: RecordDeletedArgs<T>;
};
type RecordMultiArgs<T extends TailorDBType, K extends RecordEventKind[]> = RecordArgsMap<T>[K[number]];
export type TailorDBTrigger<Args> = TailorDBTrigger$1 & {
  __args: Args;
};
type RecordTriggerOptions<T extends TailorDBType, Args> = {
  type: T;
  condition?: (args: Args) => boolean;
};
/**
 * Create a trigger that fires when a TailorDB record is created.
 * @template T
 * @param options - Trigger options
 * @returns Record created trigger
 */
export declare function recordCreatedTrigger<T extends TailorDBType>(options: RecordTriggerOptions<T, RecordCreatedArgs<T>>): TailorDBTrigger<RecordCreatedArgs<T>>;
/**
 * Create a trigger that fires when a TailorDB record is updated.
 * @template T
 * @param options - Trigger options
 * @returns Record updated trigger
 */
export declare function recordUpdatedTrigger<T extends TailorDBType>(options: RecordTriggerOptions<T, RecordUpdatedArgs<T>>): TailorDBTrigger<RecordUpdatedArgs<T>>;
/**
 * Create a trigger that fires when a TailorDB record is deleted.
 * @template T
 * @param options - Trigger options
 * @returns Record deleted trigger
 */
export declare function recordDeletedTrigger<T extends TailorDBType>(options: RecordTriggerOptions<T, RecordDeletedArgs<T>>): TailorDBTrigger<RecordDeletedArgs<T>>;
type RecordTriggerMultiOptions<T extends TailorDBType, K extends RecordEventKind[]> = {
  type: T;
  events: K;
  condition?: (args: RecordMultiArgs<T, K>) => boolean;
};
/**
 * Create a trigger that fires on multiple TailorDB record event types.
 * @template T
 * @template K
 * @param options - Trigger options with events array
 * @returns TailorDB record trigger
 */
export declare function recordTrigger<T extends TailorDBType, const K extends [RecordEventKind, ...RecordEventKind[]]>(options: RecordTriggerMultiOptions<T, K>): TailorDBTrigger<RecordMultiArgs<T, K>>;
export type ResolverExecutedTrigger<Args> = ResolverExecutedTrigger$1 & {
  __args: Args;
};
type ResolverExecutedTriggerOptions<R extends ResolverConfig> = {
  resolver: R;
  condition?: (args: ResolverExecutedArgs<R>) => boolean;
};
/**
 * Create a trigger that fires when a resolver is executed.
 * @template R
 * @param options - Trigger options
 * @returns Resolver executed trigger
 */
export declare function resolverExecutedTrigger<R extends ResolverConfig>(options: ResolverExecutedTriggerOptions<R>): ResolverExecutedTrigger<ResolverExecutedArgs<R>>;
declare const idpUserEventMap: {
  readonly created: "idp.user.created";
  readonly updated: "idp.user.updated";
  readonly deleted: "idp.user.deleted";
};
type IdpUserEventMap = typeof idpUserEventMap;
type IdpUserEventKind = keyof IdpUserEventMap;
type IdpUserArgsMap = {
  created: IdpUserCreatedArgs;
  updated: IdpUserUpdatedArgs;
  deleted: IdpUserDeletedArgs;
};
type IdpUserMultiArgs<K extends IdpUserEventKind[]> = IdpUserArgsMap[K[number]];
export type IdpUserTrigger<Args> = IdpUserTrigger$1 & {
  __args: Args;
};
type IdpUserSingleTriggerOptions = {
  /**
   * IdP namespace name to subscribe to. Required when the project defines
   * multiple IdPs; optional when a single IdP exists. Must match an IdP name
   * declared in `defineConfig({ idp: [...] })`.
   */
  idp?: IdpName;
};
/**
 * Create a trigger that fires when an IdP user is created.
 * @param options - Trigger options
 * @param options.idp - IdP namespace name to subscribe to
 * @returns IdP user created trigger
 */
export declare function idpUserCreatedTrigger(options?: IdpUserSingleTriggerOptions): IdpUserTrigger<IdpUserCreatedArgs>;
/**
 * Create a trigger that fires when an IdP user is updated.
 * @param options - Trigger options
 * @param options.idp - IdP namespace name to subscribe to
 * @returns IdP user updated trigger
 */
export declare function idpUserUpdatedTrigger(options?: IdpUserSingleTriggerOptions): IdpUserTrigger<IdpUserUpdatedArgs>;
/**
 * Create a trigger that fires when an IdP user is deleted.
 * @param options - Trigger options
 * @param options.idp - IdP namespace name to subscribe to
 * @returns IdP user deleted trigger
 */
export declare function idpUserDeletedTrigger(options?: IdpUserSingleTriggerOptions): IdpUserTrigger<IdpUserDeletedArgs>;
type IdpUserTriggerOptions<K extends IdpUserEventKind[]> = {
  events: K;
  /**
   * IdP namespace name to subscribe to. Required when the project defines
   * multiple IdPs; optional when a single IdP exists. Must match an IdP name
   * declared in `defineConfig({ idp: [...] })`.
   */
  idp?: IdpName;
};
/**
 * Create a trigger that fires on multiple IdP user event types.
 * @template K
 * @param options - Trigger options with events array
 * @param options.events - IdP user event kinds to subscribe to
 * @param options.idp - IdP namespace name to subscribe to
 * @returns IdP user trigger
 */
export declare function idpUserTrigger<const K extends [IdpUserEventKind, ...IdpUserEventKind[]]>(options: IdpUserTriggerOptions<K>): IdpUserTrigger<IdpUserMultiArgs<K>>;
declare const authAccessTokenEventMap: {
  readonly issued: "auth.access_token.issued";
  readonly refreshed: "auth.access_token.refreshed";
  readonly revoked: "auth.access_token.revoked";
};
type AuthAccessTokenEventMap = typeof authAccessTokenEventMap;
type AuthAccessTokenEventKind = keyof AuthAccessTokenEventMap;
type AuthAccessTokenArgsMap = {
  issued: AuthAccessTokenIssuedArgs;
  refreshed: AuthAccessTokenRefreshedArgs;
  revoked: AuthAccessTokenRevokedArgs;
};
type AuthAccessTokenMultiArgs<K extends AuthAccessTokenEventKind[]> = AuthAccessTokenArgsMap[K[number]];
export type AuthAccessTokenTrigger<Args> = AuthAccessTokenTrigger$1 & {
  __args: Args;
};
/**
 * Create a trigger that fires when an access token is issued.
 * @returns Auth access token issued trigger
 */
export declare function authAccessTokenIssuedTrigger(): AuthAccessTokenTrigger<AuthAccessTokenIssuedArgs>;
/**
 * Create a trigger that fires when an access token is refreshed.
 * @returns Auth access token refreshed trigger
 */
export declare function authAccessTokenRefreshedTrigger(): AuthAccessTokenTrigger<AuthAccessTokenRefreshedArgs>;
/**
 * Create a trigger that fires when an access token is revoked.
 * @returns Auth access token revoked trigger
 */
export declare function authAccessTokenRevokedTrigger(): AuthAccessTokenTrigger<AuthAccessTokenRevokedArgs>;
type AuthAccessTokenTriggerOptions<K extends AuthAccessTokenEventKind[]> = {
  events: K;
};
/**
 * Create a trigger that fires on multiple auth access token event types.
 * @template K
 * @param options - Trigger options with events array
 * @returns Auth access token trigger
 */
export declare function authAccessTokenTrigger<const K extends [AuthAccessTokenEventKind, ...AuthAccessTokenEventKind[]]>(options: AuthAccessTokenTriggerOptions<K>): AuthAccessTokenTrigger<AuthAccessTokenMultiArgs<K>>;
declare const workflowExecutionEventMap: {
  readonly started: "workflow.workflow_execution.started";
  readonly completed: "workflow.workflow_execution.completed";
  readonly retried: "workflow.workflow_execution.retried";
  readonly resumed: "workflow.workflow_execution.resumed";
  readonly wait_started: "workflow.workflow_execution.wait_started";
  readonly wait_resolved: "workflow.workflow_execution.wait_resolved";
};
type WorkflowExecutionEventKind = keyof typeof workflowExecutionEventMap;
type WorkflowExecutionArgsMap = {
  started: WorkflowExecutionStartedArgs;
  completed: WorkflowExecutionCompletedArgs;
  retried: WorkflowExecutionRetriedArgs;
  resumed: WorkflowExecutionResumedArgs;
  wait_started: WorkflowExecutionWaitStartedArgs;
  wait_resolved: WorkflowExecutionWaitResolvedArgs;
};
type WorkflowExecutionMultiArgs<K extends WorkflowExecutionEventKind[]> = WorkflowExecutionArgsMap[K[number]];
export type WorkflowExecutionTrigger<Args> = WorkflowExecutionTrigger$1 & {
  __args: Args;
};
type WorkflowExecutionSingleTriggerOptions<Args> = {
  /** Workflow to subscribe to. */
  workflow: Workflow;
  condition?: (args: Args) => boolean;
};
/**
 * Create a trigger that fires when a workflow execution starts running.
 * @param options - Trigger options
 * @param options.workflow - Workflow to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow execution started trigger
 */
export declare function workflowExecutionStartedTrigger(options: WorkflowExecutionSingleTriggerOptions<WorkflowExecutionStartedArgs>): WorkflowExecutionTrigger<WorkflowExecutionStartedArgs>;
/**
 * Create a trigger that fires when a workflow execution succeeds or fails.
 * @param options - Trigger options
 * @param options.workflow - Workflow to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow execution completed trigger
 */
export declare function workflowExecutionCompletedTrigger(options: WorkflowExecutionSingleTriggerOptions<WorkflowExecutionCompletedArgs>): WorkflowExecutionTrigger<WorkflowExecutionCompletedArgs>;
/**
 * Create a trigger that fires when a workflow execution is retried by its retry policy.
 * @param options - Trigger options
 * @param options.workflow - Workflow to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow execution retried trigger
 */
export declare function workflowExecutionRetriedTrigger(options: WorkflowExecutionSingleTriggerOptions<WorkflowExecutionRetriedArgs>): WorkflowExecutionTrigger<WorkflowExecutionRetriedArgs>;
/**
 * Create a trigger that fires when a failed workflow execution is manually resumed.
 * @param options - Trigger options
 * @param options.workflow - Workflow to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow execution resumed trigger
 */
export declare function workflowExecutionResumedTrigger(options: WorkflowExecutionSingleTriggerOptions<WorkflowExecutionResumedArgs>): WorkflowExecutionTrigger<WorkflowExecutionResumedArgs>;
/**
 * Create a trigger that fires when a workflow execution starts waiting on a wait point.
 * @param options - Trigger options
 * @param options.workflow - Workflow to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow execution wait started trigger
 */
export declare function workflowExecutionWaitStartedTrigger(options: WorkflowExecutionSingleTriggerOptions<WorkflowExecutionWaitStartedArgs>): WorkflowExecutionTrigger<WorkflowExecutionWaitStartedArgs>;
/**
 * Create a trigger that fires when a waiting workflow execution is released.
 * @param options - Trigger options
 * @param options.workflow - Workflow to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow execution wait resolved trigger
 */
export declare function workflowExecutionWaitResolvedTrigger(options: WorkflowExecutionSingleTriggerOptions<WorkflowExecutionWaitResolvedArgs>): WorkflowExecutionTrigger<WorkflowExecutionWaitResolvedArgs>;
type WorkflowExecutionTriggerOptions<K extends WorkflowExecutionEventKind[]> = {
  events: K;
  /** Workflow to subscribe to. */
  workflow: Workflow;
  condition?: (args: WorkflowExecutionMultiArgs<K>) => boolean;
};
/**
 * Create a trigger that fires on multiple workflow execution event types.
 * @template K
 * @param options - Trigger options with events array
 * @param options.events - Workflow execution event kinds to subscribe to
 * @param options.workflow - Workflow to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow execution trigger
 */
export declare function workflowExecutionTrigger<const K extends [WorkflowExecutionEventKind, ...WorkflowExecutionEventKind[]]>(options: WorkflowExecutionTriggerOptions<K>): WorkflowExecutionTrigger<WorkflowExecutionMultiArgs<K>>;
declare const workflowJobExecutionEventMap: {
  readonly started: "workflow.workflow_execution.job_execution.started";
  readonly completed: "workflow.workflow_execution.job_execution.completed";
  readonly wait_started: "workflow.workflow_execution.job_execution.wait_started";
  readonly wait_resolved: "workflow.workflow_execution.job_execution.wait_resolved";
};
type WorkflowJobExecutionEventKind = keyof typeof workflowJobExecutionEventMap;
type WorkflowJobExecutionArgsMap = {
  started: WorkflowJobExecutionStartedArgs;
  completed: WorkflowJobExecutionCompletedArgs;
  wait_started: WorkflowJobExecutionWaitStartedArgs;
  wait_resolved: WorkflowJobExecutionWaitResolvedArgs;
};
type WorkflowJobExecutionMultiArgs<K extends WorkflowJobExecutionEventKind[]> = WorkflowJobExecutionArgsMap[K[number]];
export type WorkflowJobExecutionTrigger<Args> = WorkflowJobExecutionTrigger$1 & {
  __args: Args;
};
type WorkflowJobExecutionSingleTriggerOptions<Args> = {
  /** Workflow whose job executions to subscribe to. */
  workflow: Workflow;
  condition?: (args: Args) => boolean;
};
/**
 * Create a trigger that fires when a job inside a workflow starts running.
 * @param options - Trigger options
 * @param options.workflow - Workflow whose job executions to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow job execution started trigger
 */
export declare function workflowJobExecutionStartedTrigger(options: WorkflowJobExecutionSingleTriggerOptions<WorkflowJobExecutionStartedArgs>): WorkflowJobExecutionTrigger<WorkflowJobExecutionStartedArgs>;
/**
 * Create a trigger that fires when a job inside a workflow succeeds or fails.
 *
 * A job released from a wait point reports `wait_resolved` instead of
 * `completed`; subscribe to both to observe every way a job can end.
 * @param options - Trigger options
 * @param options.workflow - Workflow whose job executions to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow job execution completed trigger
 */
export declare function workflowJobExecutionCompletedTrigger(options: WorkflowJobExecutionSingleTriggerOptions<WorkflowJobExecutionCompletedArgs>): WorkflowJobExecutionTrigger<WorkflowJobExecutionCompletedArgs>;
/**
 * Create a trigger that fires when a job inside a workflow starts waiting on a wait point.
 * @param options - Trigger options
 * @param options.workflow - Workflow whose job executions to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow job execution wait started trigger
 */
export declare function workflowJobExecutionWaitStartedTrigger(options: WorkflowJobExecutionSingleTriggerOptions<WorkflowJobExecutionWaitStartedArgs>): WorkflowJobExecutionTrigger<WorkflowJobExecutionWaitStartedArgs>;
/**
 * Create a trigger that fires when a waiting job inside a workflow is released.
 * @param options - Trigger options
 * @param options.workflow - Workflow whose job executions to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow job execution wait resolved trigger
 */
export declare function workflowJobExecutionWaitResolvedTrigger(options: WorkflowJobExecutionSingleTriggerOptions<WorkflowJobExecutionWaitResolvedArgs>): WorkflowJobExecutionTrigger<WorkflowJobExecutionWaitResolvedArgs>;
type WorkflowJobExecutionTriggerOptions<K extends WorkflowJobExecutionEventKind[]> = {
  events: K;
  /** Workflow whose job executions to subscribe to. */
  workflow: Workflow;
  condition?: (args: WorkflowJobExecutionMultiArgs<K>) => boolean;
};
/**
 * Create a trigger that fires on multiple workflow job execution event types.
 * @template K
 * @param options - Trigger options with events array
 * @param options.events - Workflow job execution event kinds to subscribe to
 * @param options.workflow - Workflow whose job executions to subscribe to
 * @param options.condition - Condition function to filter events
 * @returns Workflow job execution trigger
 */
export declare function workflowJobExecutionTrigger<const K extends [WorkflowJobExecutionEventKind, ...WorkflowJobExecutionEventKind[]]>(options: WorkflowJobExecutionTriggerOptions<K>): WorkflowJobExecutionTrigger<WorkflowJobExecutionMultiArgs<K>>;
//#endregion