async () => {
            // Ensure the partition ownerships are balanced.
            const eventProcessorIds = Object.keys(claimedPartitionsMap);

            // There are 2 processors, so we should see 2 entries.
            if (eventProcessorIds.length !== 2) {
              return false;
            }

            const aProcessorPartitions = claimedPartitionsMap[eventProcessorIds[0]];
            const bProcessorPartitions = claimedPartitionsMap[eventProcessorIds[1]];
            // The delta between number of partitions each processor owns can't be more than 1.
            if (Math.abs(aProcessorPartitions.size - bProcessorPartitions.size) > 1) {
              return false;
            }

            // All partitions must be claimed.
            return aProcessorPartitions.size + bProcessorPartitions.size === partitionIds.length;
          }


async () => thrashAfterSettling


class FooPartitionProcessor {
        async processInitialize(context: InitializationContext) {
          context.setStartingPosition(EventPosition.earliest());
        }

        async processEvents(events: ReceivedEventData[], context: PartitionContext) {
          processedAtLeastOneEvent.add(context.partitionId);

          !partionCount[context.partitionId]
            ? (partionCount[context.partitionId] = 1)
            : partionCount[context.partitionId]++;

          const existingEvents = checkpointMap.get(context.partitionId)!;

          for (const event of events) {
            debug("Received event: '%s' from partition: '%s'", event.body, context.partitionId);

            if (partionCount[context.partitionId] <= 50) {
              checkpointSequenceNumbers.set(context.partitionId, event.sequenceNumber);
              await context.updateCheckpoint(event);
              existingEvents.push(event);
            }
          }
        }
        async processError(err: Error) {
          didError = true;
        }
      }


// The partitionProcess will need to add events to the partitionResultsMap as they are received
class FooPartitionProcessor implements Required<SubscriptionEventHandlers> {
        async processInitialize(context: InitializationContext) {
          loggerForTest(`processInitialize(${context.partitionId})`);
          partitionResultsMap.get(context.partitionId)!.initialized = true;
          context.setStartingPosition(EventPosition.earliest());
        }
        async processClose(reason: CloseReason, context: PartitionContext) {
          loggerForTest(`processClose(${context.partitionId})`);
          partitionResultsMap.get(context.partitionId)!.closeReason = reason;
        }
        async processEvents(events: ReceivedEventData[], context: PartitionContext) {
          partitionOwnershipArr.add(context.partitionId);
          const existingEvents = partitionResultsMap.get(context.partitionId)!.events;
          existingEvents.push(...events.map((event) => event.body));
        }
        async processError(err: Error, context: PartitionContext) {
          loggerForTest(`processError(${context.partitionId})`);
          didError = true;
          errorName = err.name;
        }
      }


// The partitionProcess will need to add events to the partitionResultsMap as they are received
class FooPartitionProcessor {
        async processInitialization(context: InitializationContext) {
          context.setStartingPosition(EventPosition.earliest());
        }
        async processEvents(events: ReceivedEventData[], context: PartitionContext) {
          partitionOwnershipArr.add(context.partitionId);
        }
        async processError() {
          didError = true;
        }
      }


class SimpleEventProcessor implements SubscriptionEventHandlers {
        async processInitialization(context: InitializationContext) {
          context.setStartingPosition(EventPosition.latest());
        }
        async processEvents(events: ReceivedEventData[], context: PartitionContext) {
          partitionIdsSet.add(context.partitionId);
          lastEnqueuedEventPropertiesMap.set(
            context.partitionId,
            context.lastEnqueuedEventProperties!
          );
        }
        async processError(err: Error, context: PartitionContext) {}
      }


// the important thing is that the EventProcessor won't be able to claim
// any partitions, causing it to go down the "I tried but failed" path.
async claimOwnership(_: PartitionOwnership[]): Promise<PartitionOwnership[]> {
          checkpointStore.claimOwnershipCalled = true;
          return [];
        }


// (these aren't used for this test)
async listOwnership(): Promise<PartitionOwnership[]> {
          return [];
        }


async updateCheckpoint(): Promise<void> {}


async listCheckpoints(): Promise<Checkpoint[]> {
          return [];
        }


async createPump() {
          pumpManager.createPumpCalled = true;
        }


async removeAllPumps() {}


async createPump() {}


async removeAllPumps(): Promise<void> {}


async processInitialize(context: InitializationContext) {
          context.setStartingPosition(EventPosition.earliest());
        }


async processEvents(events: ReceivedEventData[], context: PartitionContext) {
          processedAtLeastOneEvent.add(context.partitionId);

          !partionCount[context.partitionId]
            ? (partionCount[context.partitionId] = 1)
            : partionCount[context.partitionId]++;

          const existingEvents = checkpointMap.get(context.partitionId)!;

          for (const event of events) {
            debug("Received event: '%s' from partition: '%s'", event.body, context.partitionId);

            if (partionCount[context.partitionId] <= 50) {
              checkpointSequenceNumbers.set(context.partitionId, event.sequenceNumber);
              await context.updateCheckpoint(event);
              existingEvents.push(event);
            }
          }
        }


async processError(err: Error) {
          didError = true;
        }


async processInitialize(context: InitializationContext) {
          loggerForTest(`processInitialize(${context.partitionId})`);
          partitionResultsMap.get(context.partitionId)!.initialized = true;
          context.setStartingPosition(EventPosition.earliest());
        }


async processClose(reason: CloseReason, context: PartitionContext) {
          loggerForTest(`processClose(${context.partitionId})`);
          partitionResultsMap.get(context.partitionId)!.closeReason = reason;
        }


async processEvents(events: ReceivedEventData[], context: PartitionContext) {
          partitionOwnershipArr.add(context.partitionId);
          const existingEvents = partitionResultsMap.get(context.partitionId)!.events;
          existingEvents.push(...events.map((event) => event.body));
        }


async processError(err: Error, context: PartitionContext) {
          loggerForTest(`processError(${context.partitionId})`);
          didError = true;
          errorName = err.name;
        }


async processInitialization(context: InitializationContext) {
          context.setStartingPosition(EventPosition.earliest());
        }


async processEvents(events: ReceivedEventData[], context: PartitionContext) {
          partitionOwnershipArr.add(context.partitionId);
        }


async processError() {
          didError = true;
        }


async processInitialize(context) {
          const eventProcessorId: string = (context as any).eventProcessorId;
          const partitionId = context.partitionId;
          loggerForTest(`[${eventProcessorId}] Claimed partition ${partitionId}`);
          // For this test we don't want to actually checkpoint, just test ownership.
          context.setStartingPosition(EventPosition.latest());
          if (allPartitionsClaimed) {
            thrashAfterSettling = true;
            return;
          }

          const claimedPartitions = claimedPartitionsMap[eventProcessorId] || new Set();
          claimedPartitions.add(partitionId);
          claimedPartitionsMap[eventProcessorId] = claimedPartitions;
        }


async processEvents() {}


async processError() {}


async processClose(reason, context) {
          const eventProcessorId: string = (context as any).eventProcessorId;
          const partitionId = context.partitionId;
          const claimedPartitions = claimedPartitionsMap[eventProcessorId];
          claimedPartitions.delete(partitionId);
          loggerForTest(
            `[${(context as any).eventProcessorId}] processClose(${reason}) on partition ${
              context.partitionId
            }`
          );
          if (reason === CloseReason.OwnershipLost && allPartitionsClaimed) {
            loggerForTest(
              `[${(context as any).eventProcessorId}] Lost partition ${context.partitionId}`
            );
            thrashAfterSettling = true;
          }
        }


async processInitialization(context: InitializationContext) {
          context.setStartingPosition(EventPosition.latest());
        }


async processEvents(events: ReceivedEventData[], context: PartitionContext) {
          partitionIdsSet.add(context.partitionId);
          lastEnqueuedEventPropertiesMap.set(
            context.partitionId,
            context.lastEnqueuedEventProperties!
          );
        }


async processError(err: Error, context: PartitionContext) {}


() => {
  viewportContext(['desktop'], () => {
    before(() => {
      cy.window().then((win) => win.sessionStorage.clear());
    });

    describe('Anonymous user', () => {
      it('should redirect to login page', () => {
        cy.visit(updateEmail.UPDATE_EMAIL_URL);
        cy.location('pathname').should('contain', '/login');
      });
    });

    describe('Logged in user', () => {
      before(() => {
        updateEmail.registerAndLogin();
        cy.visit('/');
      });

      beforeEach(() => {
        cy.restoreLocalStorage();
        cy.selectUserMenuOption({
          option: 'Email Address',
        });
      });

      updateEmail.testUpdateEmailAndLogin();

      afterEach(() => {
        cy.saveLocalStorage();
      });
    });
  });
}


() => {
    before(() => {
      cy.window().then((win) => win.sessionStorage.clear());
    });

    describe('Anonymous user', () => {
      it('should redirect to login page', () => {
        cy.visit(updateEmail.UPDATE_EMAIL_URL);
        cy.location('pathname').should('contain', '/login');
      });
    });

    describe('Logged in user', () => {
      before(() => {
        updateEmail.registerAndLogin();
        cy.visit('/');
      });

      beforeEach(() => {
        cy.restoreLocalStorage();
        cy.selectUserMenuOption({
          option: 'Email Address',
        });
      });

      updateEmail.testUpdateEmailAndLogin();

      afterEach(() => {
        cy.saveLocalStorage();
      });
    });
  }


() => {
      cy.window().then((win) => win.sessionStorage.clear());
    }


(win) => win.sessionStorage.clear()


() => {
      it('should redirect to login page', () => {
        cy.visit(updateEmail.UPDATE_EMAIL_URL);
        cy.location('pathname').should('contain', '/login');
      });
    }


() => {
        cy.visit(updateEmail.UPDATE_EMAIL_URL);
        cy.location('pathname').should('contain', '/login');
      }


() => {
      before(() => {
        updateEmail.registerAndLogin();
        cy.visit('/');
      });

      beforeEach(() => {
        cy.restoreLocalStorage();
        cy.selectUserMenuOption({
          option: 'Email Address',
        });
      });

      updateEmail.testUpdateEmailAndLogin();

      afterEach(() => {
        cy.saveLocalStorage();
      });
    }


() => {
        updateEmail.registerAndLogin();
        cy.visit('/');
      }


() => {
        cy.restoreLocalStorage();
        cy.selectUserMenuOption({
          option: 'Email Address',
        });
      }


() => {
        cy.saveLocalStorage();
      }


export function renderIncoterm(params: GridCellParams) {
  return <Incoterm value={params.value!} />;
}


interface IncotermProps {
  value: GridCellValue;
}


export interface Events {
  applicationCommandCreate: { command: ApplicationCommand };
  applicationCommandDelete: { command: ApplicationCommand };
  applicationCommandUpdate: {
    oldCommand: ApplicationCommand | null;
    newCommand: ApplicationCommand;
  };
  channelCreate: { channel: GuildChannel };
  channelDelete: { channel: DMChannel | GuildChannel };
  channelPinsUpdate: { channel: TextBasedChannels; date: Date };
  channelUpdate: {
    oldChannel: DMChannel | GuildChannel;
    newChannel: DMChannel | GuildChannel;
  };
  debug: { info: string };
  warn: { info: string };
  emojiCreate: { emoji: GuildEmoji };
  emojiDelete: { emoji: GuildEmoji };
  emojiUpdate: { oldEmoji: GuildEmoji; newEmoji: GuildEmoji };
  error: { error: Error };
  guildBanAdd: { ban: GuildBan };
  guildBanRemove: { ban: GuildBan };
  guildCreate: { guild: Guild };
  guildDelete: { guild: Guild };
  guildUnavailable: { guild: Guild };
  guildIntegrationsUpdate: { guild: Guild };
  guildMemberAdd: { member: GuildMember };
  guildMemberAvailable: { member: GuildMember | PartialGuildMember };
  guildMemberRemove: { member: GuildMember | PartialGuildMember };
  guildMembersChunk: {
    members: Collection<Snowflake, GuildMember>;
    guild: Guild;
    data: { count: number; index: number; nonce: string | undefined };
  };
  guildMemberUpdate: {
    oldMember: GuildMember | PartialGuildMember;
    newMember: GuildMember;
  };
  guildUpdate: { oldGuild: Guild; newGuild: Guild };
  inviteCreate: { invite: Invite };
  inviteDelete: { invite: Invite };
  messageCreate: { message: Message };
  messageDelete: { message: Message | PartialMessage };
  messageReactionRemoveAll: { message: Message | PartialMessage };
  messageReactionRemoveEmoji: {
    reaction: MessageReaction | PartialMessageReaction;
  };
  messageDeleteBulk: {
    messages: Collection<Snowflake, Message | PartialMessage>;
  };
  messageReactionAdd: {
    message: MessageReaction | PartialMessageReaction;
    user: User | PartialUser;
  };
  messageReactionRemove: {
    reaction: MessageReaction | PartialMessageReaction;
    user: User | PartialUser;
  };
  messageUpdate: {
    oldMessage: Message | PartialMessage;
    newMessage: Message | PartialMessage;
  };
  presenceUpdate: { oldPresence: Presence | null; newPresence: Presence };
  rateLimit: { rateLimitData: RateLimitData };
  invalidRequestWarning: {
    invalidRequestWarningData: InvalidRequestWarningData;
  };
  ready: { client: Client<true> };
  invalidated: Record<string, never>;
  roleCreate: { role: Role };
  roleDelete: { role: Role };
  roleUpdate: { oldRole: Role; newRole: Role };
  threadCreate: { thread: ThreadChannel };
  threadDelete: { thread: ThreadChannel };
  threadListSync: { threads: Collection<Snowflake, ThreadChannel> };
  threadMemberUpdate: { oldMember: ThreadMember; newMember: ThreadMember };
  threadMembersUpdate: {
    oldMembers: Collection<Snowflake, ThreadMember>;
    mewMembers: Collection<Snowflake, ThreadMember>;
  };
  threadUpdate: { oldThread: ThreadChannel; newThread: ThreadChannel };
  typingStart: { typing: Typing };
  userUpdate: { oldUser: User | PartialUser; newUser: User };
  voiceStateUpdate: { oldState: VoiceState; newState: VoiceState };
  webhookUpdate: { channel: TextChannel };
  interactionCreate: { interaction: Interaction };
  shardDisconnect: { closeEvent: CloseEvent; shardId: number };
  shardError: { error: Error; shardId: number };
  shardReady: {
    shardId: number;
    unavailableGuilds: Set<Snowflake> | undefined;
  };
  shardReconnecting: { shardId: number };
  shardResume: { shardId: number; replayedEvents: number };
  stageInstanceCreate: { stageInstance: StageInstance };
  stageInstanceUpdate: {
    oldStageInstance: StageInstance | null;
    newStageInstance: StageInstance;
  };
  stageInstanceDelete: { stageInstance: StageInstance };
  stickerCreate: { sticker: Sticker };
  stickerDelete: { sticker: Sticker };
  stickerUpdate: { oldSticker: Sticker; newSticker: Sticker };
}


export type EventsMap = {
  [E in keyof Events]: UnionToTuple<keyof Events[E]>;
};


(props: SVGAttributes<SVGSVGElement>, ref: Ref<SVGSVGElement>) => (
    <svg viewBox="0 0 24 24"


function prepareProps<TValue, TProps extends { value?: any }>(
  props: WrappedProps<TValue, TProps>,
): PreparedProps<TProps> {
  // @ts-ignore Rest types may only be created from object types
  const { required, email, validations = [], renderErrorMessage, ...rest } = props;
  const value = props.value;

  const conditions = validations.map((x) => () => x(value));
  if (required) {
    conditions.push(() => {
      if (!value) {
        return { type: 'submit', message: 'Поле необходимо заполнить' };
      }
      return undefined;
    });
  }

  if (email) {
    conditions.push(() => {
      if (typeof value !== 'string' || !value.includes('@')) {
        return { message: 'Почта указана неверно' };
      }
      return undefined;
    });
  }

  const validationInfo = conditions.reduce((result, validation) => {
    const validationResult = validation();
    if (validationResult) {
      return { ...validationResult, ...(result as any) };
    }
    return result;
  }, undefined);

  return {
    validationWrapperProps: {
      validationInfo,
      renderMessage: renderErrorMessage,
    },
    controlProps: rest as any,
  };
}


function wrapControl<TComponent extends React.ComponentType<ExtractProps<TComponent>>>(
  controlType: TComponent,
): React.ComponentType<
  WrappedProps<
    ExtractValue<TComponent>,
    JSX.LibraryManagedAttributes<TComponent, { value?: ExtractValue<TComponent> } & ExtractProps<TComponent>>
  >
> {
  return (props) => {
    const { controlProps, validationWrapperProps } = prepareProps(props);
    const control = React.createElement(controlType, controlProps) as React.ReactElement<any>;
    return React.createElement(ValidationWrapper, validationWrapperProps, control);
  };
}


export function lessThanDate(value: Date): (value: Nullable<string>) => Nullable<ValidationInfo> {
  return (actualValue) => {
    const actual = parseDate(actualValue);
    if (actual && !(actual < value)) {
      return { message: 'Значение должно быть меньше чем ' + value.toString() };
    }
    return undefined;
  };
}


function parseDate(value: Nullable<string>): Nullable<Date> {
  if (!value) {
    return null;
  }
  const match = /(\d{2}).(\d{2})\.(\d{4})/.exec(value);
  if (!match) {
    return null;
  }
  const [, dd, mm, yyyy] = match;
  return new Date(`${yyyy}.${mm}.${dd}`);
}


(x) => () => x(value)


() => x(value)


() => {
      if (!value) {
        return { type: 'submit', message: 'Поле необходимо заполнить' };
      }
      return undefined;
    }


() => {
      if (typeof value !== 'string' || !value.includes('@')) {
        return { message: 'Почта указана неверно' };
      }
      return undefined;
    }


(result, validation) => {
    const validationResult = validation();
    if (validationResult) {
      return { ...validationResult, ...(result as any) };
    }
    return result;
  }


(props) => {
    const { controlProps, validationWrapperProps } = prepareProps(props);
    const control = React.createElement(controlType, controlProps) as React.ReactElement<any>;
    return React.createElement(ValidationWrapper, validationWrapperProps, control);
  }


(actualValue) => {
    const actual = parseDate(actualValue);
    if (actual && !(actual < value)) {
      return { message: 'Значение должно быть меньше чем ' + value.toString() };
    }
    return undefined;
  }


interface ValidationProps<TValue> {
  required?: boolean;
  email?: boolean;
  validations?: Array<(value: Nullable<TValue>) => Nullable<ValidationInfo>>;
  renderErrorMessage?: RenderErrorMessage;
}


interface PreparedProps<TProps> {
  validationWrapperProps: {
    validationInfo: Nullable<ValidationInfo>;
    renderMessage: Nullable<RenderErrorMessage>;
  };
  controlProps: TProps;
}


type WrappedProps<TValue, TProps extends { value?: TValue }> = TProps & ValidationProps<TValue>;


type ExtractProps<TComponentOrTProps> = TComponentOrTProps extends React.ComponentType<infer P>
  ? P extends { value?: any }
    ? P
    : never
  : never;


type ExtractValue<TComponent> = ExtractProps<TComponent> extends { value?: null | infer TValue } ? TValue : never;


() => {
	return applyDecorators(
		ApiBearerAuth(),
		ApiOperation({ summary: '[ADMIN] get genre by genre id' }),
		ApiOkResponse({ description: 'get genre by genre id', type: SuccessReturnGenreSwagger }),
		ApiBadRequestResponse({
			description: CommonErrorMessages.ID_INVALID,
			type: BadRequestInvalidIdSwagger,
		}),
		ApiUnauthorizedResponse({
			description: AuthErrorMessages.UNAUTHORIZED,
			type: UnauthorizedSwagger,
		}),
		ApiForbiddenResponse({ description: AuthErrorMessages.FORBIDDEN, type: ForbiddenSwagger }),
		ApiNotFoundResponse({
			description: GenreErrorMessages.GENRE_NOT_FOUND,
			type: NotFoundGenreSwagger,
		}),
	);
}


@Module({
  imports: [
    MongooseModule.forFeature([{ name: 'Group', schema: GroupSchema }]),
  ],
  providers: [GroupsService, GroupsResolver],
  exports: [GroupsService],
})
export class GroupsModule {}


() => {
  let component: TableCellAppInstancesComponent<any>;
  let fixture: ComponentFixture<TableCellAppInstancesComponent<any>>;

  beforeEach(async(() => {
    TestBed.configureTestingModule({
      declarations: [
        TableCellAppInstancesComponent,
        RunningInstancesComponent
      ],
      imports: [
        ...generateCfStoreModules(),
        CoreModule,
      ],
      providers: [
        PaginationMonitorFactory
      ]
    })
      .compileComponents();
  }));

  beforeEach(() => {
    fixture = TestBed.createComponent(TableCellAppInstancesComponent);
    component = fixture.componentInstance;
    component.row = { entity: {}, metadata: {} };
    fixture.detectChanges();
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });
}


() => {
    TestBed.configureTestingModule({
      declarations: [
        TableCellAppInstancesComponent,
        RunningInstancesComponent
      ],
      imports: [
        ...generateCfStoreModules(),
        CoreModule,
      ],
      providers: [
        PaginationMonitorFactory
      ]
    })
      .compileComponents();
  }


() => {
    fixture = TestBed.createComponent(TableCellAppInstancesComponent);
    component = fixture.componentInstance;
    component.row = { entity: {}, metadata: {} };
    fixture.detectChanges();
  }


export function getElementDepthCount() {
  return instructionState.lFrame.elementDepthCount;
}


export function increaseElementDepthCount() {
  instructionState.lFrame.elementDepthCount++;
}


export function decreaseElementDepthCount() {
  instructionState.lFrame.elementDepthCount--;
}


export function getBindingsEnabled(): boolean {
  return instructionState.bindingsEnabled;
}


/**
 * Enables directive matching on elements.
 *
 *  * Example:
 * ```
 * <my-comp my-directive>
 *   Should match component / directive.
 * </my-comp>
 * <div ngNonBindable>
 *   <!-- ɵɵdisableBindings() -->
 *   <my-comp my-directive>
 *     Should not match component / directive because we are in ngNonBindable.
 *   </my-comp>
 *   <!-- ɵɵenableBindings() -->
 * </div>
 * ```
 *
 * @codeGenApi
 */
export function ɵɵenableBindings(): void {
  instructionState.bindingsEnabled = true;
}


/**
 * Disables directive matching on element.
 *
 *  * Example:
 * ```
 * <my-comp my-directive>
 *   Should match component / directive.
 * </my-comp>
 * <div ngNonBindable>
 *   <!-- ɵɵdisableBindings() -->
 *   <my-comp my-directive>
 *     Should not match component / directive because we are in ngNonBindable.
 *   </my-comp>
 *   <!-- ɵɵenableBindings() -->
 * </div>
 * ```
 *
 * @codeGenApi
 */
export function ɵɵdisableBindings(): void {
  instructionState.bindingsEnabled = false;
}


/**
 * Return the current `LView`.
 */
export function getLView(): LView {
  return instructionState.lFrame.lView;
}


/**
 * Return the current `TView`.
 */
export function getTView(): TView {
  return instructionState.lFrame.tView;
}


/**
 * Restores `contextViewData` to the given OpaqueViewState instance.
 *
 * Used in conjunction with the getCurrentView() instruction to save a snapshot
 * of the current view and restore it when listeners are invoked. This allows
 * walking the declaration view tree in listeners to get vars from parent views.
 *
 * @param viewToRestore The OpaqueViewState instance to restore.
 *
 * @codeGenApi
 */
export function ɵɵrestoreView(viewToRestore: OpaqueViewState) {
  instructionState.lFrame.contextLView = viewToRestore as any as LView;
}


export function getPreviousOrParentTNode(): TNode {
  return instructionState.lFrame.previousOrParentTNode;
}


export function setPreviousOrParentTNode(tNode: TNode, isParent: boolean) {
  instructionState.lFrame.previousOrParentTNode = tNode;
  instructionState.lFrame.isParent = isParent;
}


export function getIsParent(): boolean {
  return instructionState.lFrame.isParent;
}


export function setIsNotParent(): void {
  instructionState.lFrame.isParent = false;
}


export function setIsParent(): void {
  instructionState.lFrame.isParent = true;
}


export function getContextLView(): LView {
  return instructionState.lFrame.contextLView;
}


export function getCheckNoChangesMode(): boolean {
  // TODO(misko): remove this from the LView since it is ngDevMode=true mode only.
  return instructionState.checkNoChangesMode;
}


export function setCheckNoChangesMode(mode: boolean): void {
  instructionState.checkNoChangesMode = mode;
}


// top level variables should not be exported for performance reasons (PERF_NOTES.md)
export function getBindingRoot() {
  const lFrame = instructionState.lFrame;
  let index = lFrame.bindingRootIndex;
  if (index === -1) {
    index = lFrame.bindingRootIndex = lFrame.tView.bindingStartIndex;
  }
  return index;
}


export function getBindingIndex(): number {
  return instructionState.lFrame.bindingIndex;
}


export function setBindingIndex(value: number): number {
  return instructionState.lFrame.bindingIndex = value;
}


export function nextBindingIndex(): number {
  return instructionState.lFrame.bindingIndex++;
}


export function incrementBindingIndex(count: number): number {
  const lFrame = instructionState.lFrame;
  const index = lFrame.bindingIndex;
  lFrame.bindingIndex = lFrame.bindingIndex + count;
  return index;
}


/**
 * Set a new binding root index so that host template functions can execute.
 *
 * Bindings inside the host template are 0 index. But because we don't know ahead of time
 * how many host bindings we have we can't pre-compute them. For this reason they are all
 * 0 index and we just shift the root so that they match next available location in the LView.
 *
 * @param bindingRootIndex Root index for `hostBindings`
 * @param currentDirectiveIndex `TData[currentDirectiveIndex]` will point to the current directive
 *        whose `hostBindings` are being processed.
 */
export function setBindingRootForHostBindings(
    bindingRootIndex: number, currentDirectiveIndex: number) {
  const lFrame = instructionState.lFrame;
  lFrame.bindingIndex = lFrame.bindingRootIndex = bindingRootIndex;
  lFrame.currentDirectiveIndex = currentDirectiveIndex;
}


/**
 * When host binding is executing this points to the directive index.
 * `TView.data[getCurrentDirectiveIndex()]` is `DirectiveDef`
 * `LView[getCurrentDirectiveIndex()]` is directive instance.
 */
export function getCurrentDirectiveIndex(): number {
  return instructionState.lFrame.currentDirectiveIndex;
}


export function getCurrentQueryIndex(): number {
  return instructionState.lFrame.currentQueryIndex;
}


export function setCurrentQueryIndex(value: number): void {
  instructionState.lFrame.currentQueryIndex = value;
}


/**
 * This is a light weight version of the `enterView` which is needed by the DI system.
 * @param newView
 * @param tNode
 */
export function enterDI(newView: LView, tNode: TNode) {
  ngDevMode && assertLViewOrUndefined(newView);
  const newLFrame = allocLFrame();
  instructionState.lFrame = newLFrame;
  newLFrame.previousOrParentTNode = tNode!;
  newLFrame.lView = newView;
}


/**
 * Swap the current lView with a new lView.
 *
 * For performance reasons we store the lView in the top level of the module.
 * This way we minimize the number of properties to read. Whenever a new view
 * is entered we have to store the lView for later, and when the view is
 * exited the state has to be restored
 *
 * @param newView New lView to become active
 * @param tNode Element to which the View is a child of
 * @returns the previously active lView;
 */
export function enterView(newView: LView, tNode: TNode|null): void {
  ngDevMode && assertLViewOrUndefined(newView);
  const newLFrame = allocLFrame();
  if (ngDevMode) {
    assertEqual(newLFrame.isParent, true, 'Expected clean LFrame');
    assertEqual(newLFrame.lView, null, 'Expected clean LFrame');
    assertEqual(newLFrame.tView, null, 'Expected clean LFrame');
    assertEqual(newLFrame.selectedIndex, 0, 'Expected clean LFrame');
    assertEqual(newLFrame.elementDepthCount, 0, 'Expected clean LFrame');
    assertEqual(newLFrame.currentDirectiveIndex, -1, 'Expected clean LFrame');
    assertEqual(newLFrame.currentNamespace, null, 'Expected clean LFrame');
    assertEqual(newLFrame.currentSanitizer, null, 'Expected clean LFrame');
    assertEqual(newLFrame.bindingRootIndex, -1, 'Expected clean LFrame');
    assertEqual(newLFrame.currentQueryIndex, 0, 'Expected clean LFrame');
  }
  const tView = newView[TVIEW];
  instructionState.lFrame = newLFrame;
  newLFrame.previousOrParentTNode = tNode!;
  newLFrame.lView = newView;
  newLFrame.tView = tView;
  newLFrame.contextLView = newView!;
  newLFrame.bindingIndex = tView.bindingStartIndex;
}


/**
 * Allocates next free LFrame. This function tries to reuse the `LFrame`s to lower memory pressure.
 */
function allocLFrame() {
  const currentLFrame = instructionState.lFrame;
  const childLFrame = currentLFrame === null ? null : currentLFrame.child;
  const newLFrame = childLFrame === null ? createLFrame(currentLFrame) : childLFrame;
  return newLFrame;
}


function createLFrame(parent: LFrame|null): LFrame {
  const lFrame: LFrame = {
    previousOrParentTNode: null!,  //
    isParent: true,                //
    lView: null!,                  //
    tView: null!,                  //
    selectedIndex: 0,              //
    contextLView: null!,           //
    elementDepthCount: 0,          //
    currentNamespace: null,        //
    currentSanitizer: null,        //
    currentDirectiveIndex: -1,     //
    bindingRootIndex: -1,          //
    bindingIndex: -1,              //
    currentQueryIndex: 0,          //
    parent: parent!,               //
    child: null,                   //
  };
  parent !== null && (parent.child = lFrame);  // link the new LFrame for reuse.
  return lFrame;
}


/**
 * A lightweight version of leave which is used with DI.
 *
 * This function only resets `previousOrParentTNode` and `LView` as those are the only properties
 * used with DI (`enterDI()`).
 *
 * NOTE: This function is reexported as `leaveDI`. However `leaveDI` has return type of `void` where
 * as `leaveViewLight` has `LFrame`. This is so that `leaveViewLight` can be used in `leaveView`.
 */
function leaveViewLight(): LFrame {
  const oldLFrame = instructionState.lFrame;
  instructionState.lFrame = oldLFrame.parent;
  oldLFrame.previousOrParentTNode = null!;
  oldLFrame.lView = null!;
  return oldLFrame;
}


/**
 * Leave the current `LView`
 *
 * This pops the `LFrame` with the associated `LView` from the stack.
 *
 * IMPORTANT: We must zero out the `LFrame` values here otherwise they will be retained. This is
 * because for performance reasons we don't release `LFrame` but rather keep it for next use.
 */
export function leaveView() {
  const oldLFrame = leaveViewLight();
  oldLFrame.isParent = true;
  oldLFrame.tView = null!;
  oldLFrame.selectedIndex = 0;
  oldLFrame.contextLView = null!;
  oldLFrame.elementDepthCount = 0;
  oldLFrame.currentDirectiveIndex = -1;
  oldLFrame.currentNamespace = null;
  oldLFrame.currentSanitizer = null;
  oldLFrame.bindingRootIndex = -1;
  oldLFrame.bindingIndex = -1;
  oldLFrame.currentQueryIndex = 0;
}


export function nextContextImpl<T = any>(level: number): T {
  const contextLView = instructionState.lFrame.contextLView =
      walkUpViews(level, instructionState.lFrame.contextLView!);
  return contextLView[CONTEXT] as T;
}


function walkUpViews(nestingLevel: number, currentView: LView): LView {
  while (nestingLevel > 0) {
    ngDevMode &&
        assertDefined(
            currentView[DECLARATION_VIEW],
            'Declaration view should be defined if nesting level is greater than 0.');
    currentView = currentView[DECLARATION_VIEW]!;
    nestingLevel--;
  }
  return currentView;
}


/**
 * Gets the currently selected element index.
 *
 * Used with {@link property} instruction (and more in the future) to identify the index in the
 * current `LView` to act on.
 */
export function getSelectedIndex() {
  return instructionState.lFrame.selectedIndex;
}


/**
 * Sets the most recent index passed to {@link select}
 *
 * Used with {@link property} instruction (and more in the future) to identify the index in the
 * current `LView` to act on.
 *
 * (Note that if an "exit function" was set earlier (via `setElementExitFn()`) then that will be
 * run if and when the provided `index` value is different from the current selected index value.)
 */
export function setSelectedIndex(index: number) {
  instructionState.lFrame.selectedIndex = index;
}


/**
 * Gets the `tNode` that represents currently selected element.
 */
export function getSelectedTNode() {
  const lFrame = instructionState.lFrame;
  return getTNode(lFrame.tView, lFrame.selectedIndex);
}


/**
 * Sets the namespace used to create elements to `'http://www.w3.org/2000/svg'` in global state.
 *
 * @codeGenApi
 */
export function ɵɵnamespaceSVG() {
  instructionState.lFrame.currentNamespace = SVG_NAMESPACE;
}


/**
 * Sets the namespace used to create elements to `'http://www.w3.org/1998/MathML/'` in global state.
 *
 * @codeGenApi
 */
export function ɵɵnamespaceMathML() {
  instructionState.lFrame.currentNamespace = MATH_ML_NAMESPACE;
}


/**
 * Sets the namespace used to create elements to `null`, which forces element creation to use
 * `createElement` rather than `createElementNS`.
 *
 * @codeGenApi
 */
export function ɵɵnamespaceHTML() {
  namespaceHTMLInternal();
}


/**
 * Sets the namespace used to create elements to `null`, which forces element creation to use
 * `createElement` rather than `createElementNS`.
 */
export function namespaceHTMLInternal() {
  instructionState.lFrame.currentNamespace = null;
}


export function getNamespace(): string|null {
  return instructionState.lFrame.currentNamespace;
}


export function setCurrentStyleSanitizer(sanitizer: StyleSanitizeFn|null) {
  instructionState.lFrame.currentSanitizer = sanitizer;
}


export function resetCurrentStyleSanitizer() {
  setCurrentStyleSanitizer(null);
}


export function getCurrentStyleSanitizer() {
  // TODO(misko): This should throw when there is no LView, but it turns out we can get here from
  // `NodeStyleDebug` hence we return `null`. This should be fixed
  const lFrame = instructionState.lFrame;
  return lFrame === null ? null : lFrame.currentSanitizer;
}


/**
 *
 */
interface LFrame {
  /**
   * Parent LFrame.
   *
   * This is needed when `leaveView` is called to restore the previous state.
   */
  parent: LFrame;

  /**
   * Child LFrame.
   *
   * This is used to cache existing LFrames to relieve the memory pressure.
   */
  child: LFrame|null;

  /**
   * State of the current view being processed.
   *
   * An array of nodes (text, element, container, etc), pipes, their bindings, and
   * any local variables that need to be stored between invocations.
   */
  lView: LView;

  /**
   * Current `TView` associated with the `LFrame.lView`.
   *
   * One can get `TView` from `lFrame[TVIEW]` however because it is so common it makes sense to
   * store it in `LFrame` for perf reasons.
   */
  tView: TView;

  /**
   * Used to set the parent property when nodes are created and track query results.
   *
   * This is used in conjunction with `isParent`.
   */
  previousOrParentTNode: TNode;

  /**
   * If `isParent` is:
   *  - `true`: then `previousOrParentTNode` points to a parent node.
   *  - `false`: then `previousOrParentTNode` points to previous node (sibling).
   */
  isParent: boolean;

  /**
   * Index of currently selected element in LView.
   *
   * Used by binding instructions. Updated as part of advance instruction.
   */
  selectedIndex: number;

  /**
   * Current pointer to the binding index.
   */
  bindingIndex: number;

  /**
   * The last viewData retrieved by nextContext().
   * Allows building nextContext() and reference() calls.
   *
   * e.g. const inner = x().$implicit; const outer = x().$implicit;
   */
  contextLView: LView;

  /**
   * Store the element depth count. This is used to identify the root elements of the template
   * so that we can then attach patch data `LView` to only those elements. We know that those
   * are the only places where the patch data could change, this way we will save on number
   * of places where tha patching occurs.
   */
  elementDepthCount: number;

  /**
   * Current namespace to be used when creating elements
   */
  currentNamespace: string|null;

  /**
   * Current sanitizer
   */
  currentSanitizer: StyleSanitizeFn|null;

  /**
   * The root index from which pure function instructions should calculate their binding
   * indices. In component views, this is TView.bindingStartIndex. In a host binding
   * context, this is the TView.expandoStartIndex + any dirs/hostVars before the given dir.
   */
  bindingRootIndex: number;

  /**
   * Current index of a View or Content Query which needs to be processed next.
   * We iterate over the list of Queries and increment current query index at every step.
   */
  currentQueryIndex: number;

  /**
   * When host binding is executing this points to the directive index.
   * `TView.data[currentDirectiveIndex]` is `DirectiveDef`
   * `LView[currentDirectiveIndex]` is directive instance.
   */
  currentDirectiveIndex: number;
}


/**
 * All implicit instruction state is stored here.
 *
 * It is useful to have a single object where all of the state is stored as a mental model
 * (rather it being spread across many different variables.)
 *
 * PERF NOTE: Turns out that writing to a true global variable is slower than
 * having an intermediate object with properties.
 */
interface InstructionState {
  /**
   * Current `LFrame`
   *
   * `null` if we have not called `enterView`
   */
  lFrame: LFrame;

  /**
   * Stores whether directives should be matched to elements.
   *
   * When template contains `ngNonBindable` then we need to prevent the runtime from matching
   * directives on children of that element.
   *
   * Example:
   * ```
   * <my-comp my-directive>
   *   Should match component / directive.
   * </my-comp>
   * <div ngNonBindable>
   *   <my-comp my-directive>
   *     Should not match component / directive because we are in ngNonBindable.
   *   </my-comp>
   * </div>
   * ```
   */
  bindingsEnabled: boolean;

  /**
   * In this mode, any changes in bindings will throw an ExpressionChangedAfterChecked error.
   *
   * Necessary to support ChangeDetectorRef.checkNoChanges().
   */
  checkNoChangesMode: boolean;
}


export function SacramentsBoldIcon(props: IconProps) {
  return (
    <Icon xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" {...props}>
      <path d="M.5 12A11.5 11.5 0 1012 .5 11.513 11.513 0 00.5 12zm5-.5a1 1 0 011-1h3.75a.25.25 0 00.25-.25V6.5a1 1 0 011-1h1a1 1 0 011 1v3.75a.25.25 0 00.25.25h3.75a1 1 0 011 1v1a1 1 0 01-1 1h-3.75a.25.25 0 00-.25.25v3.75a1 1 0 01-1 1h-1a1 1 0 01-1-1v-3.75a.25.25 0 00-.25-.25H6.5a1 1 0 01-1-1z" />
    </Icon>
  )
}


(iconProps: IFluentIconsProps, props: React.HTMLAttributes<HTMLElement>): JSX.Element => {
  const {
    primaryFill,
    className
  } = iconProps;
  return <svg {...props} width={24} height={24} viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg" className={className}><path d="M15.28 6.03c-.3.3-.77.3-1.06 0l-1.47-1.47v3.69a.75.75 0 01-1.5 0V4.56L9.78 6.03a.75.75 0 01-1.06-1.06l2.75-2.75a.75.75 0 011.06 0l2.75 2.75c.3.3.3.77 0 1.06z" fill={primaryFill} /><path d="M6.03 14.22a.75.75 0 11-1.06 1.06l-2.75-2.75a.75.75 0 010-1.06l2.75-2.75a.75.75 0 011.06 1.06l-1.47 1.47h3.69a.75.75 0 010 1.5H4.56l1.47 1.47z" fill={primaryFill} /><path d="M17.97 15.28a.75.75 0 010-1.06l1.47-1.47h-3.69a.75.75 0 010-1.5h3.69l-1.47-1.47a.75.75 0 011.06-1.06l2.75 2.75a.75.75 0 010 1.06l-2.75 2.75c-.3.3-.77.3-1.06 0z" fill={primaryFill} /><path d="M15.28 17.97a.75.75 0 00-1.06 0l-1.47 1.47v-3.69a.75.75 0 00-1.5 0v3.69l-1.47-1.47a.75.75 0 00-1.06 1.06l2.75 2.75a.75.75 0 001.06 0l2.75-2.75c.3-.3.3-.77 0-1.06z" fill={primaryFill} /></svg>;
}


startAnimationForLineChart(chart) {
    let seq: any, delays: any, durations: any;
    seq = 0;
    delays = 80;
    durations = 500;

    chart.on('draw', function (data) {
      if (data.type === 'line' || data.type === 'area') {
        data.element.animate({
          d: {
            begin: 600,
            dur: 700,
            from: data.path.clone().scale(1, 0).translate(0, data.chartRect.height()).stringify(),
            to: data.path.clone().stringify(),
            easing: Chartist.Svg.Easing.easeOutQuint
          }
        });
      } else if (data.type === 'point') {
        seq++;
        data.element.animate({
          opacity: {
            begin: seq * delays,
            dur: durations,
            from: 0,
            to: 1,
            easing: 'ease'
          }
        });
      }
    });

    seq = 0;
  }


startAnimationForBarChart(chart) {
    let seq2: any, delays2: any, durations2: any;

    seq2 = 0;
    delays2 = 80;
    durations2 = 500;
    chart.on('draw', function (data) {
      if (data.type === 'bar') {
        seq2++;
        data.element.animate({
          opacity: {
            begin: seq2 * delays2,
            dur: durations2,
            from: 0,
            to: 1,
            easing: 'ease'
          }
        });
      }
    });

    seq2 = 0;
  }


ngOnInit() {
    /* ----------==========     Visitas na semana Chart initialization For Documentation    ==========---------- */

    const dataDailySalesChart: any = {
      labels: ['M', 'T', 'W', 'T', 'F', 'S', 'S'],
      series: [
        [12, 17, 7, 17, 23, 18, 38]
      ]
    };

    const optionsDailySalesChart: any = {
      lineSmooth: Chartist.Interpolation.cardinal({
        tension: 0
      }),
      low: 0,
      high: 50, // creative tim: we recommend you to set the high sa the biggest value + something for a better look
      chartPadding: { top: 0, right: 0, bottom: 0, left: 0 },
    }

    var dailySalesChart = new Chartist.Line('#dailySalesChart', dataDailySalesChart, optionsDailySalesChart);

    this.startAnimationForLineChart(dailySalesChart);

    /* ----------==========    Visitas no ano Chart initialization    ==========---------- */

    var datawebsiteViewsChart = {
      labels: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
      series: [
        [542, 443, 320, 780, 553, 453, 326, 434, 568, 610, 756, 895]

      ]
    };
    var optionswebsiteViewsChart = {
      axisX: {
        showGrid: false
      },
      low: 0,
      high: 1000,
      chartPadding: { top: 0, right: 5, bottom: 0, left: 0 }
    };
    var responsiveOptions: any[] = [
      ['screen and (max-width: 640px)', {
        seriesBarDistance: 5,
        axisX: {
          labelInterpolationFnc: function (value) {
            return value[0];
          }
        }
      }]
    ];
    var websiteViewsChart = new Chartist.Bar('#websiteViewsChart', datawebsiteViewsChart, optionswebsiteViewsChart, responsiveOptions);

    //start animation for the Emails Subscription Chart
    this.startAnimationForBarChart(websiteViewsChart);

    /* ----------==========     Avaliacoes na semana  Chart initialization    ==========---------- */

    const dataCompletedTasksChart: any = {
      labels: ['M', 'T', 'W', 'T', 'F', 'S', 'S'],
      series: [
        [20, 50, 45, 30, 28, 24, 20,]
      ]
    };

    const optionsCompletedTasksChart: any = {
      lineSmooth: Chartist.Interpolation.cardinal({
        tension: 0
      }),
      low: 0,
      high: 60, // creative tim: we recommend you to set the high sa the biggest value + something for a better look
      chartPadding: { top: 0, right: 0, bottom: 0, left: 0 }
    }

    var completedTasksChart = new Chartist.Line('#completedTasksChart', dataCompletedTasksChart, optionsCompletedTasksChart);

    // start animation for the Completed Tasks Chart - Line Chart
    this.startAnimationForLineChart(completedTasksChart);

    /* ----------==========    avaliações no ano Chart initialization    ==========---------- */

    var avaliacoesAnoViewsChart = {
      labels: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
      series: [
        [542, 443, 320, 780, 553, 453, 326, 434, 568, 610, 756, 895]

      ]
    };
    var optionsAvaliacoesAnoChart = {
      axisX: {
        showGrid: false
      },
      low: 0,
      high: 1000,
      chartPadding: { top: 0, right: 5, bottom: 0, left: 0 }
    };
    var responsiveOptions: any[] = [
      ['screen and (max-width: 640px)', {
        seriesBarDistance: 5,
        axisX: {
          labelInterpolationFnc: function (value) {
            return value[0];
          }
        }
      }]
    ];
    var avaliacoesAnoChart = new Chartist.Bar('#avaliacoesAnoChart', avaliacoesAnoViewsChart, optionsAvaliacoesAnoChart, responsiveOptions);

    //start animation for the Emails Subscription Chart
    this.startAnimationForBarChart(avaliacoesAnoChart);

    /* ----------==========     Motivacao na semana Chart initialization    ==========---------- */

    const dataMotivationChart: any = {
      labels: ['M', 'T', 'W', 'T', 'F', 'S', 'S'],
      series: [
        [2.2, 4, 5, 5, 2, 4, 3],
        [5, 4, 4, 4, 3.5, 5, 5],
        [4.5,4.5,3.5,5,3.5,4,3.5]
      ]
    };

    const optionsMotivationChart: any = {
      lineSmooth: Chartist.Interpolation.cardinal({
        tension: 0
      }),
      low: 1,
      high: 6, // creative tim: we recommend you to set the high sa the biggest value + something for a better look
      chartPadding: { top: 0, right: 0, bottom: 0, left: 0 },
    }

    var motivationChart = new Chartist.Line('#motivationChart', dataMotivationChart, optionsMotivationChart);

    this.startAnimationForLineChart(motivationChart);

    /* ----------==========    Motivacoes no ano Chart initialization    ==========---------- */

    var motivacaoAnoViewsChart = {
      labels: ['J', 'F', 'M', 'A', 'M', 'J', 'J', 'A', 'S', 'O', 'N', 'D'],
      series: [
        [5, 4, 3.5, 4, 4, 3.5, 5, 5, 3, 2, 4, 5],
        [3, 3, 3, 4, 4, 4, 4.5, 3, 5, 5, 5, 4.6],
        [3.2, 3.6, 4.2, 4.5, 4.2, 4.3, 4.8, 5, 4.6, 3.9, 4.2, 5]

      ]
    };
    var optionsmotivacaoAnoViewsChart = {
      axisX: {
        showGrid: false
      },
      low: 1,
      high: 6,
      chartPadding: { top: 0, right: 5, bottom: 0, left: 0 }
    };
    var responsiveOptions: any[] = [
      ['screen and (max-width: 640px)', {
        seriesBarDistance: 5,
        axisX: {
          labelInterpolationFnc: function (value) {
            return value[0];
          }
        }
      }]
    ];
    var motivacaoanoViewsChart = new Chartist.Bar('#motivacaoanoViewsChart', motivacaoAnoViewsChart, optionsmotivacaoAnoViewsChart, responsiveOptions);

    //start animation for the Emails Subscription Chart
    this.startAnimationForBarChart(motivacaoanoViewsChart);

  }


/**
 * A DDoS protection plan in a resource group.
 */
export function getDdosProtectionPlan(args: GetDdosProtectionPlanArgs, opts?: pulumi.InvokeOptions): Promise<GetDdosProtectionPlanResult> {
    if (!opts) {
        opts = {}
    }

    if (!opts.version) {
        opts.version = utilities.getVersion();
    }
    return pulumi.runtime.invoke("azure-native:network/v20181001:getDdosProtectionPlan", {
        "ddosProtectionPlanName": args.ddosProtectionPlanName,
        "resourceGroupName": args.resourceGroupName,
    }, opts);
}


export interface GetDdosProtectionPlanArgs {
    /**
     * The name of the DDoS protection plan.
     */
    ddosProtectionPlanName: string;
    /**
     * The name of the resource group.
     */
    resourceGroupName: string;
}


/**
 * A DDoS protection plan in a resource group.
 */
export interface GetDdosProtectionPlanResult {
    /**
     * A unique read-only string that changes whenever the resource is updated.
     */
    readonly etag: string;
    /**
     * Resource ID.
     */
    readonly id: string;
    /**
     * Resource location.
     */
    readonly location?: string;
    /**
     * Resource name.
     */
    readonly name: string;
    /**
     * The provisioning state of the DDoS protection plan resource. Possible values are: 'Succeeded', 'Updating', 'Deleting', and 'Failed'.
     */
    readonly provisioningState: string;
    /**
     * The resource GUID property of the DDoS protection plan resource. It uniquely identifies the resource, even if the user changes its name or migrate the resource across subscriptions or resource groups.
     */
    readonly resourceGuid: string;
    /**
     * Resource tags.
     */
    readonly tags?: {[key: string]: string};
    /**
     * Resource type.
     */
    readonly type: string;
    /**
     * The list of virtual networks associated with the DDoS protection plan resource. This list is read-only.
     */
    readonly virtualNetworks: outputs.network.v20181001.SubResourceResponse[];
}


export default function reducer(
  state: ContractsState = initialState,
  action: any
) {
  const {type, ...payload} = action;

  switch (type) {
    case CLEAR_CONTRACTS:
      return clearContracts(state);
    case CONTRACT_BANK_ADAPTER:
      return contractBankAdapter(state, payload);
    case CONTRACT_BANK_EXTENSION:
      return contractBankExtension(state, payload);
    case CONTRACT_BANK_FACTORY:
      return contractBankFactory(state, payload);
    case CONTRACT_CONFIGURATION:
      return contractConfiguration(state, payload);
    case CONTRACT_COUPON_ONBOARDING:
      return contractCouponOnboarding(state, payload);
    case CONTRACT_DAO_FACTORY:
      return contractDAOFactory(state, payload);
    case CONTRACT_DAO_REGISTRY:
      return contractDAORegistry(state, payload);
    case CONTRACT_DAO_REGISTRY_ADAPTER:
      return contractDaoRegistryAdapter(state, payload);
    case CONTRACT_DISTRIBUTE:
      return contractDistribute(state, payload);
    case CONTRACT_ERC20_EXTENSION:
      return contractERC20Extension(state, payload);
    case CONTRACT_FINANCING:
      return contractFinancing(state, payload);
    case CONTRACT_GUILDKICK:
      return contractGuildBank(state, payload);
    case CONTRACT_MANAGING:
      return contractManaging(state, payload);
    case CONTRACT_NFT_ADAPTER:
      return contractNFTAdapter(state, payload);
    case CONTRACT_NFT_EXTENSION:
      return contractNFTExtension(state, payload);
    case CONTRACT_ONBOARDING:
      return contractOnboarding(state, payload);
    case CONTRACT_RAGEQUIT:
      return contractRagequit(state, payload);
    case CONTRACT_TRIBUTE:
      return contractTribute(state, payload);
    case CONTRACT_TRIBUTE_NFT:
      return contractTributeNFT(state, payload);
    case CONTRACT_VOTING:
      return contractVoting(state, payload);
    case CONTRACT_VOTING_OP_ROLLUP:
      return contractVoting(state, payload);

    default:
      return state;
  }
}


function clearContracts(state: ContractsState) {
  return {...state, ...initialState};
}


function contractBankFactory(state: ContractsState, payload: any) {
  return {...state, BankFactoryContract: {...payload}};
}


function contractDAOFactory(state: ContractsState, payload: any) {
  return {...state, DaoFactoryContract: {...payload}};
}


function contractDAORegistry(state: ContractsState, payload: any) {
  return {...state, DaoRegistryContract: {...payload}};
}


function contractDaoRegistryAdapter(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, DaoRegistryAdapterContract: {...payload}};
}


function contractBankExtension(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, BankExtensionContract: {...payload}};
}


function contractConfiguration(state: ContractsState, payload: any) {
  return {...state, ConfigurationContract: {...payload}};
}


function contractDistribute(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, DistributeContract: {...payload}};
}


function contractFinancing(state: ContractsState, payload: any) {
  return {...state, FinancingContract: {...payload}};
}


function contractGuildBank(state: ContractsState, payload: any) {
  return {...state, GuildBankContract: {...payload}};
}


function contractOnboarding(state: ContractsState, payload: any) {
  return {...state, OnboardingContract: {...payload}};
}


function contractRagequit(state: ContractsState, payload: any) {
  return {...state, RagequitContract: {...payload}};
}


function contractTribute(state: ContractsState, payload: any): ContractsState {
  return {...state, TributeContract: {...payload}};
}


function contractVoting(state: ContractsState, payload: any): ContractsState {
  return {...state, VotingContract: {...payload}};
}


function contractManaging(state: ContractsState, payload: any): ContractsState {
  return {...state, ManagingContract: {...payload}};
}


function contractBankAdapter(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, BankAdapterContract: {...payload}};
}


function contractNFTAdapter(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, NFTAdapterContract: {...payload}};
}


function contractTributeNFT(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, TributeNFTContract: {...payload}};
}


function contractCouponOnboarding(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, CouponOnboardingContract: {...payload}};
}


function contractNFTExtension(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, NFTExtensionContract: {...payload}};
}


function contractERC20Extension(
  state: ContractsState,
  payload: any
): ContractsState {
  return {...state, ERC20ExtensionContract: {...payload}};
}


/**
 * [[SimulcastTransceiverController]] implements [[VideoStreamIndex]] to facilitate video stream
 * subscription and includes query functions for stream id and attendee id.
 */
export default class SimulcastVideoStreamIndex extends DefaultVideoStreamIndex {
    private streamIdToBitrateKbpsMap;
    static readonly UNSEEN_STREAM_BITRATE = -2;
    static readonly RECENTLY_INACTIVE_STREAM_BITRATE = -1;
    static readonly NOT_SENDING_STREAM_BITRATE = 0;
    static readonly BitratesMsgFrequencyMs: number;
    private _localStreamInfos;
    private _lastBitRateMsgTime;
    constructor(logger: Logger);
    localStreamDescriptions(): VideoStreamDescription[];
    integrateUplinkPolicyDecision(encodingParams: RTCRtpEncodingParameters[]): void;
    integrateBitratesFrame(bitrateFrame: SdkBitrateFrame): void;
    private logLocalStreamDescriptions;
    integrateIndexFrame(indexFrame: SdkIndexFrame): void;
    integrateSubscribeAckFrame(subscribeAck: SdkSubscribeAckFrame): void;
}


localStreamDescriptions(): VideoStreamDescription[];


integrateUplinkPolicyDecision(encodingParams: RTCRtpEncodingParameters[]): void;


integrateBitratesFrame(bitrateFrame: SdkBitrateFrame): void;


integrateIndexFrame(indexFrame: SdkIndexFrame): void;


integrateSubscribeAckFrame(subscribeAck: SdkSubscribeAckFrame): void;


async (
  input: SendSerialConsoleSSHPublicKeyCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "content-type": "application/x-amz-json-1.1",
    "x-amz-target": "AWSEC2InstanceConnectService.SendSerialConsoleSSHPublicKey",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1SendSerialConsoleSSHPublicKeyRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
}


async (
  input: SendSSHPublicKeyCommandInput,
  context: __SerdeContext
): Promise<__HttpRequest> => {
  const headers: __HeaderBag = {
    "content-type": "application/x-amz-json-1.1",
    "x-amz-target": "AWSEC2InstanceConnectService.SendSSHPublicKey",
  };
  let body: any;
  body = JSON.stringify(serializeAws_json1_1SendSSHPublicKeyRequest(input, context));
  return buildHttpRpcRequest(context, headers, "/", undefined, body);
}


async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<SendSerialConsoleSSHPublicKeyCommandOutput> => {
  if (output.statusCode >= 300) {
    return deserializeAws_json1_1SendSerialConsoleSSHPublicKeyCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1SendSerialConsoleSSHPublicKeyResponse(data, context);
  const response: SendSerialConsoleSSHPublicKeyCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
}


async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<SendSerialConsoleSSHPublicKeyCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode = "UnknownError";
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
  switch (errorCode) {
    case "AuthException":
    case "com.amazonaws.ec2instanceconnect#AuthException":
      response = {
        ...(await deserializeAws_json1_1AuthExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "EC2InstanceNotFoundException":
    case "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException":
      response = {
        ...(await deserializeAws_json1_1EC2InstanceNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "EC2InstanceTypeInvalidException":
    case "com.amazonaws.ec2instanceconnect#EC2InstanceTypeInvalidException":
      response = {
        ...(await deserializeAws_json1_1EC2InstanceTypeInvalidExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidArgsException":
    case "com.amazonaws.ec2instanceconnect#InvalidArgsException":
      response = {
        ...(await deserializeAws_json1_1InvalidArgsExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "SerialConsoleAccessDisabledException":
    case "com.amazonaws.ec2instanceconnect#SerialConsoleAccessDisabledException":
      response = {
        ...(await deserializeAws_json1_1SerialConsoleAccessDisabledExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "SerialConsoleSessionLimitExceededException":
    case "com.amazonaws.ec2instanceconnect#SerialConsoleSessionLimitExceededException":
      response = {
        ...(await deserializeAws_json1_1SerialConsoleSessionLimitExceededExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "SerialConsoleSessionUnavailableException":
    case "com.amazonaws.ec2instanceconnect#SerialConsoleSessionUnavailableException":
      response = {
        ...(await deserializeAws_json1_1SerialConsoleSessionUnavailableExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ServiceException":
    case "com.amazonaws.ec2instanceconnect#ServiceException":
      response = {
        ...(await deserializeAws_json1_1ServiceExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ThrottlingException":
    case "com.amazonaws.ec2instanceconnect#ThrottlingException":
      response = {
        ...(await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
}


async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<SendSSHPublicKeyCommandOutput> => {
  if (output.statusCode >= 300) {
    return deserializeAws_json1_1SendSSHPublicKeyCommandError(output, context);
  }
  const data: any = await parseBody(output.body, context);
  let contents: any = {};
  contents = deserializeAws_json1_1SendSSHPublicKeyResponse(data, context);
  const response: SendSSHPublicKeyCommandOutput = {
    $metadata: deserializeMetadata(output),
    ...contents,
  };
  return Promise.resolve(response);
}


async (
  output: __HttpResponse,
  context: __SerdeContext
): Promise<SendSSHPublicKeyCommandOutput> => {
  const parsedOutput: any = {
    ...output,
    body: await parseBody(output.body, context),
  };
  let response: __SmithyException & __MetadataBearer & { [key: string]: any };
  let errorCode = "UnknownError";
  errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
  switch (errorCode) {
    case "AuthException":
    case "com.amazonaws.ec2instanceconnect#AuthException":
      response = {
        ...(await deserializeAws_json1_1AuthExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "EC2InstanceNotFoundException":
    case "com.amazonaws.ec2instanceconnect#EC2InstanceNotFoundException":
      response = {
        ...(await deserializeAws_json1_1EC2InstanceNotFoundExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "InvalidArgsException":
    case "com.amazonaws.ec2instanceconnect#InvalidArgsException":
      response = {
        ...(await deserializeAws_json1_1InvalidArgsExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ServiceException":
    case "com.amazonaws.ec2instanceconnect#ServiceException":
      response = {
        ...(await deserializeAws_json1_1ServiceExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    case "ThrottlingException":
    case "com.amazonaws.ec2instanceconnect#ThrottlingException":
      response = {
        ...(await deserializeAws_json1_1ThrottlingExceptionResponse(parsedOutput, context)),
        name: errorCode,
        $metadata: deserializeMetadata(output),
      };
      break;
    default:
      const parsedBody = parsedOutput.body;
      errorCode = parsedBody.code || parsedBody.Code || errorCode;
      response = {
        ...parsedBody,
        name: `${errorCode}`,
        message: parsedBody.message || parsedBody.Message || errorCode,
        $fault: "client",
        $metadata: deserializeMetadata(output),
      } as any;
  }
  const message = response.message || response.Message || errorCode;
  response.message = message;
  delete response.Message;
  return Promise.reject(Object.assign(new Error(message), response));
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<AuthException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1AuthException(body, context);
  const contents: AuthException = {
    name: "AuthException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<EC2InstanceNotFoundException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1EC2InstanceNotFoundException(body, context);
  const contents: EC2InstanceNotFoundException = {
    name: "EC2InstanceNotFoundException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<EC2InstanceTypeInvalidException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1EC2InstanceTypeInvalidException(body, context);
  const contents: EC2InstanceTypeInvalidException = {
    name: "EC2InstanceTypeInvalidException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<InvalidArgsException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1InvalidArgsException(body, context);
  const contents: InvalidArgsException = {
    name: "InvalidArgsException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<SerialConsoleAccessDisabledException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1SerialConsoleAccessDisabledException(body, context);
  const contents: SerialConsoleAccessDisabledException = {
    name: "SerialConsoleAccessDisabledException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<SerialConsoleSessionLimitExceededException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1SerialConsoleSessionLimitExceededException(body, context);
  const contents: SerialConsoleSessionLimitExceededException = {
    name: "SerialConsoleSessionLimitExceededException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<SerialConsoleSessionUnavailableException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1SerialConsoleSessionUnavailableException(body, context);
  const contents: SerialConsoleSessionUnavailableException = {
    name: "SerialConsoleSessionUnavailableException",
    $fault: "server",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ServiceException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ServiceException(body, context);
  const contents: ServiceException = {
    name: "ServiceException",
    $fault: "server",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


async (
  parsedOutput: any,
  context: __SerdeContext
): Promise<ThrottlingException> => {
  const body = parsedOutput.body;
  const deserialized: any = deserializeAws_json1_1ThrottlingException(body, context);
  const contents: ThrottlingException = {
    name: "ThrottlingException",
    $fault: "client",
    $metadata: deserializeMetadata(parsedOutput),
    ...deserialized,
  };
  return contents;
}


(
  input: SendSerialConsoleSSHPublicKeyRequest,
  context: __SerdeContext
): any => {
  return {
    ...(input.InstanceId !== undefined && input.InstanceId !== null && { InstanceId: input.InstanceId }),
    ...(input.SSHPublicKey !== undefined && input.SSHPublicKey !== null && { SSHPublicKey: input.SSHPublicKey }),
    ...(input.SerialPort !== undefined && input.SerialPort !== null && { SerialPort: input.SerialPort }),
  };
}


(input: SendSSHPublicKeyRequest, context: __SerdeContext): any => {
  return {
    ...(input.AvailabilityZone !== undefined &&
      input.AvailabilityZone !== null && { AvailabilityZone: input.AvailabilityZone }),
    ...(input.InstanceId !== undefined && input.InstanceId !== null && { InstanceId: input.InstanceId }),
    ...(input.InstanceOSUser !== undefined &&
      input.InstanceOSUser !== null && { InstanceOSUser: input.InstanceOSUser }),
    ...(input.SSHPublicKey !== undefined && input.SSHPublicKey !== null && { SSHPublicKey: input.SSHPublicKey }),
  };
}


(output: any, context: __SerdeContext): AuthException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(
  output: any,
  context: __SerdeContext
): EC2InstanceNotFoundException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(
  output: any,
  context: __SerdeContext
): EC2InstanceTypeInvalidException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(output: any, context: __SerdeContext): InvalidArgsException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(
  output: any,
  context: __SerdeContext
): SendSerialConsoleSSHPublicKeyResponse => {
  return {
    RequestId: __expectString(output.RequestId),
    Success: __expectBoolean(output.Success),
  } as any;
}


(
  output: any,
  context: __SerdeContext
): SendSSHPublicKeyResponse => {
  return {
    RequestId: __expectString(output.RequestId),
    Success: __expectBoolean(output.Success),
  } as any;
}


(
  output: any,
  context: __SerdeContext
): SerialConsoleAccessDisabledException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(
  output: any,
  context: __SerdeContext
): SerialConsoleSessionLimitExceededException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(
  output: any,
  context: __SerdeContext
): SerialConsoleSessionUnavailableException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(output: any, context: __SerdeContext): ServiceException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(output: any, context: __SerdeContext): ThrottlingException => {
  return {
    Message: __expectString(output.Message),
  } as any;
}


(output: __HttpResponse): __ResponseMetadata => ({
  httpStatusCode: output.statusCode,
  requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"],
  extendedRequestId: output.headers["x-amz-id-2"],
  cfId: output.headers["x-amz-cf-id"],
})


(streamBody: any = new Uint8Array(), context: __SerdeContext): Promise<Uint8Array> => {
  if (streamBody instanceof Uint8Array) {
    return Promise.resolve(streamBody);
  }
  return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array());
}


(streamBody: any, context: __SerdeContext): Promise<string> =>
  collectBody(streamBody, context).then((body) => context.utf8Encoder(body))


(body) => context.utf8Encoder(body)


async (
  context: __SerdeContext,
  headers: __HeaderBag,
  path: string,
  resolvedHostname: string | undefined,
  body: any
): Promise<__HttpRequest> => {
  const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
  const contents: any = {
    protocol,
    hostname,
    port,
    method: "POST",
    path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
    headers,
  };
  if (resolvedHostname !== undefined) {
    contents.hostname = resolvedHostname;
  }
  if (body !== undefined) {
    contents.body = body;
  }
  return new __HttpRequest(contents);
}


(streamBody: any, context: __SerdeContext): any =>
  collectBodyString(streamBody, context).then((encoded) => {
    if (encoded.length) {
      return JSON.parse(encoded);
    }
    return {};
  })


(encoded) => {
    if (encoded.length) {
      return JSON.parse(encoded);
    }
    return {};
  }


(output: __HttpResponse, data: any): string => {
  const findKey = (object: any, key: string) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());

  const sanitizeErrorCode = (rawValue: string): string => {
    let cleanValue = rawValue;
    if (cleanValue.indexOf(":") >= 0) {
      cleanValue = cleanValue.split(":")[0];
    }
    if (cleanValue.indexOf("#") >= 0) {
      cleanValue = cleanValue.split("#")[1];
    }
    return cleanValue;
  };

  const headerKey = findKey(output.headers, "x-amzn-errortype");
  if (headerKey !== undefined) {
    return sanitizeErrorCode(output.headers[headerKey]);
  }

  if (data.code !== undefined) {
    return sanitizeErrorCode(data.code);
  }

  if (data["__type"] !== undefined) {
    return sanitizeErrorCode(data["__type"]);
  }

  return "";
}


(object: any, key: string) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase())


(k) => k.toLowerCase() === key.toLowerCase()


declare class index {
  static defaultMaxListeners: any;
  static init(): void;
  static listenerCount(emitter: any, type: any): any;
  static tag: string;
  static usingDomains: boolean;
  constructor(options: any);
  broadcast: any;
  interval: any;
  serviceTag: any;
  port: any;
  peerInfo: any;
  addListener(type: any, listener: any): any;
  emit(type: any, args: any): any;
  eventNames(): any;
  getMaxListeners(): any;
  listenerCount(type: any): any;
  listeners(type: any): any;
  off(type: any, listener: any): any;
  on(type: any, listener: any): any;
  once(type: any, listener: any): any;
  prependListener(type: any, listener: any): any;
  prependOnceListener(type: any, listener: any): any;
  rawListeners(type: any): any;
  removeAllListeners(type: any, ...args: any[]): any;
  removeListener(type: any, listener: any): any;
  setMaxListeners(n: any): any;
  start(callback: any): void;
  stop(callback: any): void;
}


class EventEmitter {
    // Circular reference from index.EventEmitter
    static EventEmitter: any;
    static defaultMaxListeners: any;
    static init(): void;
    static listenerCount(emitter: any, type: any): any;
    static usingDomains: boolean;
    addListener(type: any, listener: any): any;
    emit(type: any, args: any): any;
    eventNames(): any;
    getMaxListeners(): any;
    listenerCount(type: any): any;
    listeners(type: any): any;
    off(type: any, listener: any): any;
    on(type: any, listener: any): any;
    once(type: any, listener: any): any;
    prependListener(type: any, listener: any): any;
    prependOnceListener(type: any, listener: any): any;
    rawListeners(type: any): any;
    removeAllListeners(type: any, ...args: any[]): any;
    removeListener(type: any, listener: any): any;
    setMaxListeners(n: any): any;
  }


static init(): void;


static listenerCount(emitter: any, type: any): any;


addListener(type: any, listener: any): any;


emit(type: any, args: any): any;


eventNames(): any;


getMaxListeners(): any;


listenerCount(type: any): any;


listeners(type: any): any;


off(type: any, listener: any): any;


on(type: any, listener: any): any;


once(type: any, listener: any): any;


prependListener(type: any, listener: any): any;


prependOnceListener(type: any, listener: any): any;


rawListeners(type: any): any;


removeAllListeners(type: any, ...args: any[]): any;


removeListener(type: any, listener: any): any;


setMaxListeners(n: any): any;


start(callback: any): void;


stop(callback: any): void;


@Injectable()
export class AuthGuard implements CanActivate {
  constructor(private router: Router) { }

  canActivate() {
    if (BackendService.isLoggedIn()) {
      return true;
    }
    else {
      this.router.navigate(["/login"]);
      return false;
    }
  }
}


canActivate() {
    if (BackendService.isLoggedIn()) {
      return true;
    }
    else {
      this.router.navigate(["/login"]);
      return false;
    }
  }


({ image, nickname, statusMesg, obsoleted, liveMode, stream, speakerOn }) => (
    <div className="FaceImages-card"


({
    roomId,
    userId,
    nickname,
    statusMesg,
    liveMode,
    micOn,
    speakerOn,
    videoDeviceId,
    audioDeviceId,
  }) => {
    const { myImage, roomImages } = useFaceImages(
      roomId,
      userId,
      nickname,
      statusMesg,
      liveMode,
      videoDeviceId
    );
    const { faceStream, faceStreamMap } = useFaceVideos(
      roomId,
      userId,
      liveMode,
      liveMode,
      micOn,
      videoDeviceId,
      audioDeviceId
    );

    return (
      <div className="FaceImage-container">
        <FaceImage
          image={myImage}
          nickname={nickname}
          statusMesg={statusMesg}
          liveMode={liveMode}
          stream={faceStream || undefined}


(item) => (
          <FaceImage
            key={item.userId}


() => {
  let component: ReportInventoryPage;
  let fixture: ComponentFixture<ReportInventoryPage>;

  beforeEach(async(() => {
    TestBed.configureTestingModule({
      declarations: [ ReportInventoryPage ],
      schemas: [CUSTOM_ELEMENTS_SCHEMA],
    })
    .compileComponents();
  }));

  beforeEach(() => {
    fixture = TestBed.createComponent(ReportInventoryPage);
    component = fixture.componentInstance;
    fixture.detectChanges();
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });
}


() => {
    TestBed.configureTestingModule({
      declarations: [ ReportInventoryPage ],
      schemas: [CUSTOM_ELEMENTS_SCHEMA],
    })
    .compileComponents();
  }


() => {
    fixture = TestBed.createComponent(ReportInventoryPage);
    component = fixture.componentInstance;
    fixture.detectChanges();
  }


interface IntrinsicAttributes {
    isToggled?: boolean;
    onClick?: (any?) => void;
  }


export function expectArraysClose(
    actual: Tensor|TypedArray|number[],
    expected: Tensor|TypedArray|number[]|boolean[], epsilon = TEST_EPSILON) {
  if (!(actual instanceof Tensor) && !(expected instanceof Tensor)) {
    const aType = actual.constructor.name;
    const bType = expected.constructor.name;

    if (aType !== bType) {
      throw new Error(
          `Arrays are of different type actual: ${aType} ` +
          `vs expected: ${bType}`);
    }
  } else if (actual instanceof Tensor && expected instanceof Tensor) {
    if (actual.dtype !== expected.dtype) {
      throw new Error(
          `Arrays are of different type actual: ${actual.dtype} ` +
          `vs expected: ${expected.dtype}.`);
    }
    if (!util.arraysEqual(actual.shape, expected.shape)) {
      throw new Error(
          `Arrays are of different shape actual: ${actual.shape} ` +
          `vs expected: ${expected.shape}.`);
    }
  }

  let actualValues: TypedArray|number[];
  let expectedValues: TypedArray|number[]|boolean[];
  if (actual instanceof Tensor) {
    actualValues = actual.dataSync();
  } else {
    actualValues = actual;
  }
  if (expected instanceof Tensor) {
    expectedValues = expected.dataSync();
  } else {
    expectedValues = expected;
  }

  if (actualValues.length !== expectedValues.length) {
    throw new Error(
        `Arrays have different lengths actual: ${actualValues.length} vs ` +
        `expected: ${expectedValues.length}.\n` +
        `Actual:   ${actualValues}.\n` +
        `Expected: ${expectedValues}.`);
  }
  for (let i = 0; i < expectedValues.length; ++i) {
    const a = actualValues[i];
    const e = expectedValues[i];

    if (!areClose(a, Number(e), epsilon)) {
      throw new Error(
          `Arrays differ: actual[${i}] = ${a}, expected[${i}] = ${e}.\n` +
          `Actual:   ${actualValues}.\n` +
          `Expected: ${expectedValues}.`);
    }
  }
}


export function expectArraysEqual(
    actual: Tensor|TypedArray|number[],
    expected: Tensor|TypedArray|number[]|boolean[]) {
  return expectArraysClose(actual, expected, 0);
}


export function expectNumbersClose(
    a: number, e: number, epsilon = TEST_EPSILON) {
  if (!areClose(a, e, epsilon)) {
    throw new Error(`Numbers differ: actual === ${a}, expected === ${e}`);
  }
}


function areClose(a: number, e: number, epsilon: number): boolean {
  if (isNaN(a) && isNaN(e)) {
    return true;
  }
  if (isNaN(a) || isNaN(e) || Math.abs(a - e) > epsilon) {
    return false;
  }
  return true;
}


export function expectValuesInRange(
    actual: Tensor|TypedArray|number[], low: number, high: number) {
  let actualVals: TypedArray|number[];
  if (actual instanceof Tensor) {
    actualVals = actual.dataSync();
  } else {
    actualVals = actual;
  }
  for (let i = 0; i < actualVals.length; i++) {
    if (actualVals[i] < low || actualVals[i] > high) {
      throw new Error(
          `Value out of range:${actualVals[i]} low: ${low}, high: ${high}`);
    }
  }
}


export function describeWithFlags(
    name: string, featuresList: Features[], tests: () => void) {
  featuresList.forEach(features => {
    const testName = name + ' ' + JSON.stringify(features);
    executeTests(testName, tests, features);
  });
}


function executeTests(
    testName: string, tests: () => void, features?: Features) {
  describe(testName, () => {
    beforeEach(() => {
      ENV.setFeatures(features || {});
      ENV.addCustomBackend('webgl', () => new MathBackendWebGL());
      ENV.addCustomBackend('cpu', () => new MathBackendCPU());
      if (features && features.BACKEND != null) {
        Environment.setBackend(features.BACKEND);
      }
      ENV.engine.startScope();
    });

    afterEach(() => {
      ENV.engine.endScope(null);
      ENV.reset();
    });

    tests();
  });
}


export function assertIsNan(val: number, dtype: DataType) {
  if (!util.isValNaN(val, dtype)) {
    throw new Error(`Value ${val} does not represent NaN for dtype ${dtype}`);
  }
}


features => {
    const testName = name + ' ' + JSON.stringify(features);
    executeTests(testName, tests, features);
  }


() => {
    beforeEach(() => {
      ENV.setFeatures(features || {});
      ENV.addCustomBackend('webgl', () => new MathBackendWebGL());
      ENV.addCustomBackend('cpu', () => new MathBackendCPU());
      if (features && features.BACKEND != null) {
        Environment.setBackend(features.BACKEND);
      }
      ENV.engine.startScope();
    });

    afterEach(() => {
      ENV.engine.endScope(null);
      ENV.reset();
    });

    tests();
  }


() => {
      ENV.setFeatures(features || {});
      ENV.addCustomBackend('webgl', () => new MathBackendWebGL());
      ENV.addCustomBackend('cpu', () => new MathBackendCPU());
      if (features && features.BACKEND != null) {
        Environment.setBackend(features.BACKEND);
      }
      ENV.engine.startScope();
    }


() => new MathBackendWebGL()


() => new MathBackendCPU()


() => {
      ENV.engine.endScope(null);
      ENV.reset();
    }


() => {
  return (
    <div className="text-center">
      <Button type="primary">Button</Button>
    </div>


export interface INumberFormatOptions extends NumberFormatOptions {
  compactDisplay?: INumberFormatCompactDisplay;

  currency?: INumberFormatCurrency;
  currencyDisplay?: INumberFormatCurrencyDisplay;
  currencySign?: INumberFormatCurrencySign;

  localeMatcher?: INumberFormatLocaleMatcher;
  notation?: INumberFormatNotation;
  numberingSystem?: INumberFormatNumberingSystem;

  signDisplay?: INumberFormatSignDisplay;
  style?: INumberFormatStyle;
  unit?: INumberFormatUnit;
  unitDisplay?: INumberFormatUnitDisplay;

  useGrouping?: boolean;

  minimumIntegerDigits?: number;
  minimumFractionDigits?: number;
  maximumFractionDigits?: number;
  minimumSignificantDigits?: number;
  maximumSignificantDigits?: number;
}


// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat
export type INumberFormatCompactDisplay = 'short' | 'long';


export type INumberFormatCurrency = string;


export type INumberFormatCurrencyDisplay =  'symbol' | 'narrowSymbol' | 'code' | 'name';


export type INumberFormatCurrencySign = 'accounting' | 'standard';


export type INumberFormatLocaleMatcher = ILocaleMatcher;


export type INumberFormatNotation = 'standard' | 'scientific' | 'engineering' | 'compact';


export type INumberFormatNumberingSystem = INumberingSystem;


export type INumberFormatSignDisplay = 'auto' | 'never' | 'always' | 'exceptZero';


export type INumberFormatStyle = 'decimal' | 'currency' | 'percent' | 'unit';


export type INumberFormatUnit = string;


export type INumberFormatUnitDisplay = 'long' | 'short' | 'narrow';


export type INumberFormatValue = number | bigint;


() => {
  const { theme, setTheme } = useTheme()
  const {
    color: { bg, fg, primary, secondary },
  } = theme

  const setGrey = (
    group: "bg" | "fg",
    shade: keyof GreyScale,
    color: string
  ) => {
    if (theme.color[group][shade] !== color) {
      const cpy = { ...theme }
      cpy.color.name = "custom"
      cpy.color[group][shade] = color
      setTheme(cpy)
    }
  }

  const setAccent = (
    group: "primary" | "secondary",
    shade: keyof ColorGradient,
    color: string
  ) => {
    if (theme.color[group][shade] !== color) {
      const cpy = { ...theme }
      cpy.color.name = "custom"
      cpy.color[group][shade] = color
      setTheme(cpy)
    }
  }

  const setBgShade = (value: string) => setGrey("bg", "shade", value)
  const setBgBase = (value: string) => setGrey("bg", "base", value)
  const setBgSurface = (value: string) => setGrey("bg", "surface", value)
  const setBgHighlight = (value: string) => setGrey("bg", "highlight", value)

  const setFgShade = (value: string) => setGrey("fg", "shade", value)
  const setFgBase = (value: string) => setGrey("fg", "base", value)
  const setFgSurface = (value: string) => setGrey("fg", "surface", value)
  const setFgHighlight = (value: string) => setGrey("fg", "highlight", value)

  const setPrimaryBg = (value: string) => setAccent("primary", "bg", value)
  const setPrimaryBase = (value: string) => setAccent("primary", "base", value)
  const setPrimaryFg = (value: string) => setAccent("primary", "fg", value)

  const setSecondaryBg = (value: string) => setAccent("secondary", "bg", value)
  const setSecondaryBase = (value: string) =>
    setAccent("secondary", "base", value)
  const setSecondaryFg = (value: string) => setAccent("secondary", "fg", value)

  return (
    <Wrapper>
      {/** Background */}
      <CenterLayout>

Background

      </CenterLayout>
      <CenterLayout>
        <ColorInput label="Unused" value={bg.shade} onChange={setBgShade} />
        <ColorInput label="Background" value={bg.base} onChange={setBgBase} />
        <ColorInput
          label="Surface background"
          value={bg.surface}
          onChange={setBgSurface}
        />
        <ColorInput
          label="Icon:focus"
          value={bg.highlight}
          onChange={setBgHighlight}
        />
      </CenterLayout>

      {/** Forground */}
      <CenterLayout>

Forground

      </CenterLayout>
      <CenterLayout>
        <ColorInput label="Unused" value={fg.shade} onChange={setFgShade} />
        <ColorInput label="Input border" value={fg.base} onChange={setFgBase} />
        <ColorInput
          label="Bookmark label | Input text"
          value={fg.surface}
          onChange={setFgSurface}
        />
        <ColorInput
          label="Unused"
          value={fg.highlight}
          onChange={setFgHighlight}
        />
      </CenterLayout>

      {/** Primary */}
      <CenterLayout>

Primary

      </CenterLayout>
      <CenterLayout>
        <ColorInput
          label="Shadow start"
          value={primary.bg}
          onChange={setPrimaryBg}
        />
        <ColorInput
          label="Surface border | Icon:hover | Input:focus"
          value={primary.base}
          onChange={setPrimaryBase}
        />
        <ColorInput
          label="Headline | Icon"
          value={primary.fg}
          onChange={setPrimaryFg}
        />
      </CenterLayout>

      {/** Secondary */}
      <CenterLayout>

Secondary

      </CenterLayout>
      <CenterLayout>
        <ColorInput
          label="Shadow end"
          value={secondary.bg}
          onChange={setSecondaryBg}
        />
        <ColorInput
          label="Unused"
          value={secondary.base}
          onChange={setSecondaryBase}
        />
        <ColorInput
          label="Group label"
          value={secondary.fg}
          onChange={setSecondaryFg}
        />
      </CenterLayout>
    </Wrapper>


(
    group: "bg" | "fg",
    shade: keyof GreyScale,
    color: string
  ) => {
    if (theme.color[group][shade] !== color) {
      const cpy = { ...theme }
      cpy.color.name = "custom"
      cpy.color[group][shade] = color
      setTheme(cpy)
    }
  }


(
    group: "primary" | "secondary",
    shade: keyof ColorGradient,
    color: string
  ) => {
    if (theme.color[group][shade] !== color) {
      const cpy = { ...theme }
      cpy.color.name = "custom"
      cpy.color[group][shade] = color
      setTheme(cpy)
    }
  }


(value: string) => setGrey("bg", "shade", value)


(value: string) => setGrey("bg", "base", value)


(value: string) => setGrey("bg", "surface", value)


(value: string) => setGrey("bg", "highlight", value)


(value: string) => setGrey("fg", "shade", value)


(value: string) => setGrey("fg", "base", value)


(value: string) => setGrey("fg", "surface", value)


(value: string) => setGrey("fg", "highlight", value)


(value: string) => setAccent("primary", "bg", value)


(value: string) => setAccent("primary", "base", value)


(value: string) => setAccent("primary", "fg", value)


(value: string) => setAccent("secondary", "bg", value)


(value: string) =>
    setAccent("secondary", "base", value)


(value: string) => setAccent("secondary", "fg", value)


export function useUserAddress(
    fundingPotId: string | undefined,
    colonyClient: ColonyClient | null
) {
    const [userAddress, setUserAddress] = React.useState<string>();

    useEffect(() => {
        (async () => {
            if (fundingPotId && colonyClient) {
                const humanReadableFundingPotId = new utils.BigNumber(
                    fundingPotId
                ).toString();
                const { associatedTypeId } = await colonyClient.getFundingPot(
                    humanReadableFundingPotId
                );
                const {
                    recipient: _userAddress,
                } = await colonyClient.getPayment(associatedTypeId);
                setUserAddress(_userAddress);
            }
        })();
    }, [colonyClient, fundingPotId]);

    return userAddress;
}


() => {
        (async () => {
            if (fundingPotId && colonyClient) {
                const humanReadableFundingPotId = new utils.BigNumber(
                    fundingPotId
                ).toString();
                const { associatedTypeId } = await colonyClient.getFundingPot(
                    humanReadableFundingPotId
                );
                const {
                    recipient: _userAddress,
                } = await colonyClient.getPayment(associatedTypeId);
                setUserAddress(_userAddress);
            }
        })();
    }


async () => {
            if (fundingPotId && colonyClient) {
                const humanReadableFundingPotId = new utils.BigNumber(
                    fundingPotId
                ).toString();
                const { associatedTypeId } = await colonyClient.getFundingPot(
                    humanReadableFundingPotId
                );
                const {
                    recipient: _userAddress,
                } = await colonyClient.getPayment(associatedTypeId);
                setUserAddress(_userAddress);
            }
        }


function createBaseGenesisState(): GenesisState {
  return {
    params: undefined,
    gauges: [],
    lockableDurations: [],
    lastGaugeId: Long.UZERO,
  };
}


(e: any) => Gauge.fromJSON(e)


(e: any) => Duration.fromJSON(e)


(e) => (e ? Gauge.toJSON(e) : undefined)


(e) =>
        e ? Duration.toJSON(e) : undefined


(e) => Gauge.fromPartial(e)


(e) => Duration.fromPartial(e)


/** GenesisState defines the incentives module's genesis state. */
export interface GenesisState {
  /** params defines all the parameters of the module */
  params?: Params;
  gauges: Gauge[];
  lockableDurations: Duration[];
  lastGaugeId: Long;
}


encode(
    message: GenesisState,
    writer: _m0.Writer = _m0.Writer.create()
  ): _m0.Writer {
    if (message.params !== undefined) {
      Params.encode(message.params, writer.uint32(10).fork()).ldelim();
    }
    for (const v of message.gauges) {
      Gauge.encode(v!, writer.uint32(18).fork()).ldelim();
    }
    for (const v of message.lockableDurations) {
      Duration.encode(v!, writer.uint32(26).fork()).ldelim();
    }
    if (!message.lastGaugeId.isZero()) {
      writer.uint32(32).uint64(message.lastGaugeId);
    }
    return writer;
  }


decode(input: _m0.Reader | Uint8Array, length?: number): GenesisState {
    const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
    let end = length === undefined ? reader.len : reader.pos + length;
    const message = createBaseGenesisState();
    while (reader.pos < end) {
      const tag = reader.uint32();
      switch (tag >>> 3) {
        case 1:
          message.params = Params.decode(reader, reader.uint32());
          break;
        case 2:
          message.gauges.push(Gauge.decode(reader, reader.uint32()));
          break;
        case 3:
          message.lockableDurations.push(
            Duration.decode(reader, reader.uint32())
          );
          break;
        case 4:
          message.lastGaugeId = reader.uint64() as Long;
          break;
        default:
          reader.skipType(tag & 7);
          break;
      }
    }
    return message;
  }


fromJSON(object: any): GenesisState {
    return {
      params: isSet(object.params) ? Params.fromJSON(object.params) : undefined,
      gauges: Array.isArray(object?.gauges)
        ? object.gauges.map((e: any) => Gauge.fromJSON(e))
        : [],
      lockableDurations: Array.isArray(object?.lockableDurations)
        ? object.lockableDurations.map((e: any) => Duration.fromJSON(e))
        : [],
      lastGaugeId: isSet(object.lastGaugeId)
        ? Long.fromString(object.lastGaugeId)
        : Long.UZERO,
    };
  }


toJSON(message: GenesisState): unknown {
    const obj: any = {};
    message.params !== undefined &&
      (obj.params = message.params ? Params.toJSON(message.params) : undefined);
    if (message.gauges) {
      obj.gauges = message.gauges.map((e) => (e ? Gauge.toJSON(e) : undefined));
    } else {
      obj.gauges = [];
    }
    if (message.lockableDurations) {
      obj.lockableDurations = message.lockableDurations.map((e) =>
        e ? Duration.toJSON(e) : undefined
      );
    } else {
      obj.lockableDurations = [];
    }
    message.lastGaugeId !== undefined &&
      (obj.lastGaugeId = (message.lastGaugeId || Long.UZERO).toString());
    return obj;
  }


fromPartial<I extends Exact<DeepPartial<GenesisState>, I>>(
    object: I
  ): GenesisState {
    const message = createBaseGenesisState();
    message.params =
      object.params !== undefined && object.params !== null
        ? Params.fromPartial(object.params)
        : undefined;
    message.gauges = object.gauges?.map((e) => Gauge.fromPartial(e)) || [];
    message.lockableDurations =
      object.lockableDurations?.map((e) => Duration.fromPartial(e)) || [];
    message.lastGaugeId =
      object.lastGaugeId !== undefined && object.lastGaugeId !== null
        ? Long.fromValue(object.lastGaugeId)
        : Long.UZERO;
    return message;
  }


/**
 * Interfaces for JSON returned from the ESPN API
 */
export interface IESPNLinkJSON {
    text: string;
    href: string;
    rel: string[];
}


export interface IESPNCompetitorsJSON {
    score: any;
    winner: boolean;
    id: string;
    team: {
        abbreviation: string;
        links: Array<IESPNLinkJSON>;
    };
}


export interface IESPNPastCompetitorsJSON extends IESPNCompetitorsJSON {
    score: {
        value: number;
        displayValue: string;
    };
}


export interface IESPNCurrentCompetitorsJSON extends IESPNCompetitorsJSON {
    score: string;
}


export interface IESPNCompetitionJSON {
    attendance: number;
    boxscoreAvailable: boolean;
    competitors: Array<any>;
    date: string;
    id: string;
    neutralSite: boolean;
    notes: Array<any>;
    status: {
        clock: number;
        displayClock: string;
        period: string;
        type: {
            completed: boolean;
            description: string;
            detail: string;
            id: string;
            name: string;
            shortDetail: string;
            state: string;
        };
    };
    ticketsAvailable: boolean;
    timeValid: boolean;
    type: {
        id: string;
        text: string;
        abbreviation: string;
    };
    venue: {
        address: {
            city: string;
            state: string;
            zipCode: string;
        };
        fullName: string;
    };
}


export interface IESPNScoreboardCompetitionJSON extends IESPNCompetitionJSON {
    competitors: Array<IESPNPastCompetitorsJSON>;
}


export interface IESPNCurrentCompetitionJSON extends IESPNCompetitionJSON {
    competitors: Array<IESPNCurrentCompetitorsJSON>;
}


export interface IESPNEvent {
    competitions: Array<any>;
    date: string;
    id: number;
    links: IESPNLinkJSON[];
    name: string;
    season: {
        year: number;
        displayName: string;
    };
    seasonType: {
        id: string;
        type: number;
        name: string;
        abbreviation: string;
    };
    shortName: string;
    timeValid: boolean;
    week: {
        number: number;
        text: string;
    };
    status: {
        clock: number;
        displayClock: string;
        period: number;
        type: {
            completed: boolean;
            description: string;
            detail: string;
            id: string;
            name: string;
            shortDetail: string;
            state: string;
        };
    };
}


export interface IESPNPastEvent extends IESPNEvent {
    competitions: Array<IESPNScoreboardCompetitionJSON>;
}


export interface IESPNCurrentEvent extends IESPNEvent {
    competitions: Array<IESPNCurrentCompetitionJSON>;
}