load => {
    it('should work with glob correctly', async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/query.graphql';
      const schema = await load(glob, {
        loaders: [new GraphQLFileLoader()]
      });

      expect(schema.getTypeMap()['User']).toBeDefined();
      expect(schema.getTypeMap()['Query']).toBeDefined();
    });

    it('should ignore empty files when using glob expressions', async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/*.empty.graphql';

      try {
        await load(glob, {
          loaders: [new GraphQLFileLoader()]
        });
        expect(true).toBeFalsy();
      } catch (e: any) {
        expect(e.message).toContain(`Unable to find any GraphQL type definitions for the following pointers:`);
        expect(e.message).toContain(`/tests/loaders/schema/test-files/schema-dir/*.empty.graphql`);
      }
    });

    it('should point to a broken file with parsing error message', async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/*.broken.graphql';

      try {
        const schema = await load(glob, {
          loaders: [new GraphQLFileLoader()]
        });
        expect(schema).toBeFalsy();
      } catch (e: any) {
        expect(e.message).toContain(`Unable to find any GraphQL type definitions for the following pointers:`);
      }
    });

    it('should ignore graphql documents when loading a schema', async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/*.non-schema.graphql';

      try {
        await load(glob, {
          loaders: [new GraphQLFileLoader()]
        });
        expect(true).toBeFalsy();
      } catch (e: any) {
        expect(e.message).toContain(`Unable to find any GraphQL type definitions for the following pointers:`);
        expect(e.message).toContain(`./tests/loaders/schema/test-files/schema-dir/*.non-schema.graphql`);
      }
    });

    it('should work with graphql-tag', async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/*.ts';

      const schema = await load(schemaPath, {
        loaders: [new CodeFileLoader()]
      });

      expect(schema.getTypeMap()['User']).toBeDefined();
      expect(schema.getTypeMap()['Query']).toBeDefined();
    });

    it('should work without globs correctly', async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/type-defs/graphql-tag.ts';
      const schema = await load(schemaPath, {
        loaders: [new CodeFileLoader()]
      });

      expect(schema.getTypeMap()['User']).toBeDefined();
      expect(schema.getTypeMap()['Query']).toBeDefined();
    });

    it('should work with import notations', async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/query.graphql';
      const schema = await load(schemaPath, {
        loaders: [new GraphQLFileLoader()]
      });

      expect(schema.getTypeMap()['User']).toBeDefined();
      expect(schema.getTypeMap()['Query']).toBeDefined();
    });

    it('should work with extensions (static graphql file)', async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/extensions/schema-with-extend.graphql';
      const schema = await load(schemaPath, {
        loaders: [new GraphQLFileLoader()]
      });
      const QueryType = schema.getQueryType()
      assertNonMaybe(QueryType)
      const queryFields = Object.keys(QueryType.getFields());

      expect(queryFields).toContain('foo');
      expect(queryFields).toContain('bar');
    });

    it('should work with extensions (multiple graphql files)', async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/extensions/*.graphql';
      const schema = await load(schemaPath, {
        loaders: [new GraphQLFileLoader()]
      });
      const QueryType = schema.getQueryType()
      assertNonMaybe(QueryType)
      const queryFields = Object.keys(QueryType.getFields());

      expect(queryFields).toContain('foo');
      expect(queryFields).toContain('bar');
      expect(queryFields).toContain('baz');
    });

    it('should work with extensions (static js file with typedefs)', async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/extensions/type-defs.js';
      const schema = await load(schemaPath, {
        loaders: [new CodeFileLoader()]
      });
      const QueryType = schema.getQueryType()
      assertNonMaybe(QueryType)
      const queryFields = Object.keys(QueryType.getFields());

      expect(queryFields).toContain('foo');
      expect(queryFields).toContain('bar');
    });

    it('should include sources on demand', async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/query.graphql';
      const schemaWithSources = await load(glob, {
        loaders: [new GraphQLFileLoader()],
        includeSources: true,
      });
      assertNonMaybe(schemaWithSources.extensions)
      const sourcesFromExtensions = schemaWithSources.extensions['sources'] as any;
      expect(sourcesFromExtensions).toBeDefined();
      expect(sourcesFromExtensions).toHaveLength(1);
      expect(sourcesFromExtensions[0]).toMatchObject(expect.objectContaining({
        name: path.resolve(process.cwd(), glob).replace(/\\/g, '/')
      }))

      const schemaWithoutSources = await load(glob, {
        loaders: [new GraphQLFileLoader()]
      });
      assertNonMaybe(schemaWithoutSources.extensions)
      expect(schemaWithoutSources.extensions['sources']).not.toBeDefined();
    });

    it('should be able to exclude documents via negative glob', async () => {
      const result = await load([
        './tests/loaders/schema/test-files/schema-dir/user.graphql',
        './tests/loaders/schema/test-files/schema-dir/invalid.graphql',
        '!./tests/loaders/schema/test-files/schema-dir/i*.graphql',
      ], {
        loaders: [new GraphQLFileLoader()],
        includeSources: true,
      });
      expect(result.getTypeMap()["User"]).toBeDefined()
    })

    it('should be able to exclude documents via nested negative glob', async () => {
      await load([
        './tests/loaders/schema/test-files/schema-dir/user.graphql',
        './tests/loaders/schema/test-files/schema-dir/invalid.graphql',
         {
        '!./tests/loaders/schema/test-files/schema-dir/i*.graphql' : {}
         }
      ], {
        loaders: [new GraphQLFileLoader()],
        includeSources: true,
      });
    })
  }


async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/query.graphql';
      const schema = await load(glob, {
        loaders: [new GraphQLFileLoader()]
      });

      expect(schema.getTypeMap()['User']).toBeDefined();
      expect(schema.getTypeMap()['Query']).toBeDefined();
    }


async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/*.empty.graphql';

      try {
        await load(glob, {
          loaders: [new GraphQLFileLoader()]
        });
        expect(true).toBeFalsy();
      } catch (e: any) {
        expect(e.message).toContain(`Unable to find any GraphQL type definitions for the following pointers:`);
        expect(e.message).toContain(`/tests/loaders/schema/test-files/schema-dir/*.empty.graphql`);
      }
    }


async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/*.broken.graphql';

      try {
        const schema = await load(glob, {
          loaders: [new GraphQLFileLoader()]
        });
        expect(schema).toBeFalsy();
      } catch (e: any) {
        expect(e.message).toContain(`Unable to find any GraphQL type definitions for the following pointers:`);
      }
    }


async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/*.non-schema.graphql';

      try {
        await load(glob, {
          loaders: [new GraphQLFileLoader()]
        });
        expect(true).toBeFalsy();
      } catch (e: any) {
        expect(e.message).toContain(`Unable to find any GraphQL type definitions for the following pointers:`);
        expect(e.message).toContain(`./tests/loaders/schema/test-files/schema-dir/*.non-schema.graphql`);
      }
    }


async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/*.ts';

      const schema = await load(schemaPath, {
        loaders: [new CodeFileLoader()]
      });

      expect(schema.getTypeMap()['User']).toBeDefined();
      expect(schema.getTypeMap()['Query']).toBeDefined();
    }


async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/type-defs/graphql-tag.ts';
      const schema = await load(schemaPath, {
        loaders: [new CodeFileLoader()]
      });

      expect(schema.getTypeMap()['User']).toBeDefined();
      expect(schema.getTypeMap()['Query']).toBeDefined();
    }


async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/query.graphql';
      const schema = await load(schemaPath, {
        loaders: [new GraphQLFileLoader()]
      });

      expect(schema.getTypeMap()['User']).toBeDefined();
      expect(schema.getTypeMap()['Query']).toBeDefined();
    }


async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/extensions/schema-with-extend.graphql';
      const schema = await load(schemaPath, {
        loaders: [new GraphQLFileLoader()]
      });
      const QueryType = schema.getQueryType()
      assertNonMaybe(QueryType)
      const queryFields = Object.keys(QueryType.getFields());

      expect(queryFields).toContain('foo');
      expect(queryFields).toContain('bar');
    }


async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/extensions/*.graphql';
      const schema = await load(schemaPath, {
        loaders: [new GraphQLFileLoader()]
      });
      const QueryType = schema.getQueryType()
      assertNonMaybe(QueryType)
      const queryFields = Object.keys(QueryType.getFields());

      expect(queryFields).toContain('foo');
      expect(queryFields).toContain('bar');
      expect(queryFields).toContain('baz');
    }


async () => {
      const schemaPath = './tests/loaders/schema/test-files/schema-dir/extensions/type-defs.js';
      const schema = await load(schemaPath, {
        loaders: [new CodeFileLoader()]
      });
      const QueryType = schema.getQueryType()
      assertNonMaybe(QueryType)
      const queryFields = Object.keys(QueryType.getFields());

      expect(queryFields).toContain('foo');
      expect(queryFields).toContain('bar');
    }


async () => {
      const glob = './tests/loaders/schema/test-files/schema-dir/query.graphql';
      const schemaWithSources = await load(glob, {
        loaders: [new GraphQLFileLoader()],
        includeSources: true,
      });
      assertNonMaybe(schemaWithSources.extensions)
      const sourcesFromExtensions = schemaWithSources.extensions['sources'] as any;
      expect(sourcesFromExtensions).toBeDefined();
      expect(sourcesFromExtensions).toHaveLength(1);
      expect(sourcesFromExtensions[0]).toMatchObject(expect.objectContaining({
        name: path.resolve(process.cwd(), glob).replace(/\\/g, '/')
      }))

      const schemaWithoutSources = await load(glob, {
        loaders: [new GraphQLFileLoader()]
      });
      assertNonMaybe(schemaWithoutSources.extensions)
      expect(schemaWithoutSources.extensions['sources']).not.toBeDefined();
    }


async () => {
      const result = await load([
        './tests/loaders/schema/test-files/schema-dir/user.graphql',
        './tests/loaders/schema/test-files/schema-dir/invalid.graphql',
        '!./tests/loaders/schema/test-files/schema-dir/i*.graphql',
      ], {
        loaders: [new GraphQLFileLoader()],
        includeSources: true,
      });
      expect(result.getTypeMap()["User"]).toBeDefined()
    }


async () => {
      await load([
        './tests/loaders/schema/test-files/schema-dir/user.graphql',
        './tests/loaders/schema/test-files/schema-dir/invalid.graphql',
         {
        '!./tests/loaders/schema/test-files/schema-dir/i*.graphql' : {}
         }
      ], {
        loaders: [new GraphQLFileLoader()],
        includeSources: true,
      });
    }


({ className, footerUrls }) => {
  return (
    <div
      className={clsx(
        'flex',
        'flex-row',
        'text-gray-400',
        'space-x-8',
        'md:space-x-4',
        className
      )}
    >
      <IconContext.Provider
        value={{
          size: '1.75em',
          className: 'footer-icon',
        }}
      >
        {createLinkedIcons(footerUrls)}
      </IconContext.Provider>
    </div>


interface Props {
  className?: string
  footerUrls: FooterUrls
}


clsx(
        'flex',
        'flex-row',
        'text-gray-400',
        'space-x-8',
        'md:space-x-4',
        className
      )


createLinkedIcons(footerUrls)


export function ProgramLogsCardBody({
  message,
  logs,
  cluster,
}: {
  message: Message | ParsedMessage;
  logs: InstructionLogs[];
  cluster: Cluster;
}) {
  return (
    <TableCardBody>
      {message.instructions.map((ix, index) => {
        let programId;
        if ("programIdIndex" in ix) {
          const programAccount = message.accountKeys[ix.programIdIndex];
          if ("pubkey" in programAccount) {
            programId = programAccount.pubkey;
          } else {
            programId = programAccount;
          }
        } else {
          programId = ix.programId;
        }

        const programName =
          programLabel(programId.toBase58(), cluster) || "Unknown Program";
        const programLogs: InstructionLogs | undefined = logs[index];

        let badgeColor = "white";
        if (programLogs) {
          badgeColor = programLogs.failed ? "warning" : "success";
        }

        return (

                <span className={`badge bg-${badgeColor}-soft me-2`}>
                  #{index + 1}

                {programName} Instruction

              {programLogs && (

                  {programLogs.logs.map((log, key) => {
                    return (

                        {log.prefix}
                        <span className={`text-${log.style}`}>{log.text}

                    );
                  })}

              )}


(ix, index) => {
        let programId;
        if ("programIdIndex" in ix) {
          const programAccount = message.accountKeys[ix.programIdIndex];
          if ("pubkey" in programAccount) {
            programId = programAccount.pubkey;
          } else {
            programId = programAccount;
          }
        } else {
          programId = ix.programId;
        }

        const programName =
          programLabel(programId.toBase58(), cluster) || "Unknown Program";
        const programLogs: InstructionLogs | undefined = logs[index];

        let badgeColor = "white";
        if (programLogs) {
          badgeColor = programLogs.failed ? "warning" : "success";
        }

        return (

                <span className={`badge bg-${badgeColor}-soft me-2`}>
                  #{index + 1}

                {programName} Instruction

              {programLogs && (

                  {programLogs.logs.map((log, key) => {
                    return (

                        {log.prefix}
                        <span className={`text-${log.style}`}>{log.text}

                    );
                  }


(log, key) => {
                    return (

                        {log.prefix}
                        <span className={`text-${log.style}`}


() => {
    return (
        <>
            <SEO
                title={'Deriv Careers | Business analyst jobs'}
                description={
                    'See job vacancies in Deriv’s Business analyst team. Join and grow with us.'
                }
            />
            <DepartmentPage data={career_data.business_excellence[0]} />
        </>


() => {
  let selectBox: LanguageSelectBox,
    eventEmitter: Emitter,
    wrapper: HTMLElement,
    input: HTMLInputElement,
    list: HTMLElement,
    wwContainer: HTMLElement;

  beforeEach(() => {
    eventEmitter = {
      emit: jest.fn(),
      emitReduce: jest.fn(),
      listen: jest.fn(),
      removeEventHandler: jest.fn(),
      addEventType: jest.fn(),
      getEvents: jest.fn(),
      holdEventInvoke: jest.fn(),
    };

    wwContainer = document.createElement('div');
    wwContainer.className = 'toastui-editor ww-mode';
    document.body.appendChild(wwContainer);

    selectBox = new LanguageSelectBox(eventEmitter, ['js', 'css', 'ts']);

    wrapper = document.body.querySelector(`.${cls(WRAPPER_CLASS_NAME)}`)!;
    input = document.body.querySelector(`.${cls(INPUT_CLASS_NANE)} > input`)!;
    list = document.body.querySelector(`.${cls(LIST_CLASS_NAME)}`)!;
  });

  afterEach(() => {
    selectBox.destroy();
    document.body.removeChild(wwContainer);
  });

  it('should create language select box element', () => {
    expect(wrapper).toHaveClass(`${cls(WRAPPER_CLASS_NAME)}`);
  });

  it('show() should show language select box element', () => {
    selectBox.show();

    expect(wrapper).not.toHaveStyle('display: none');
  });

  it('hide() should hide language select box element', () => {
    selectBox.show();
    selectBox.hide();

    expect(wrapper).toHaveStyle('display: none');
  });

  it('destory() should remove element on body', () => {
    selectBox.destroy();

    expect(wwContainer).toBeEmptyDOMElement();
    expect(eventEmitter.removeEventHandler).toHaveBeenCalled();
  });

  it('setLanguage() should change input value to selected language', () => {
    selectBox.setLanguage('foo');

    expect(input).toHaveValue('foo');
  });

  describe('wrapper element', () => {
    it('should change to active state when input is focused', () => {
      input.focus();

      expect(wrapper).toHaveClass('active');
    });

    it('should change to inactive state when input is focused out', () => {
      input.focus();
      input.blur();

      expect(wrapper).not.toHaveClass('active');
    });
  });

  describe('language list element', () => {
    it('should show when input is focused', () => {
      input.focus();

      expect(list).toHaveStyle('display: block');
    });

    it('should hide when input is focused out', () => {
      input.focus();
      input.blur();

      expect(list).toHaveStyle('display: none');
    });
  });
}


() => {
    eventEmitter = {
      emit: jest.fn(),
      emitReduce: jest.fn(),
      listen: jest.fn(),
      removeEventHandler: jest.fn(),
      addEventType: jest.fn(),
      getEvents: jest.fn(),
      holdEventInvoke: jest.fn(),
    };

    wwContainer = document.createElement('div');
    wwContainer.className = 'toastui-editor ww-mode';
    document.body.appendChild(wwContainer);

    selectBox = new LanguageSelectBox(eventEmitter, ['js', 'css', 'ts']);

    wrapper = document.body.querySelector(`.${cls(WRAPPER_CLASS_NAME)}`)!;
    input = document.body.querySelector(`.${cls(INPUT_CLASS_NANE)} > input`)!;
    list = document.body.querySelector(`.${cls(LIST_CLASS_NAME)}`)!;
  }


() => {
    selectBox.destroy();
    document.body.removeChild(wwContainer);
  }


() => {
    expect(wrapper).toHaveClass(`${cls(WRAPPER_CLASS_NAME)}`);
  }


() => {
    selectBox.show();

    expect(wrapper).not.toHaveStyle('display: none');
  }


() => {
    selectBox.show();
    selectBox.hide();

    expect(wrapper).toHaveStyle('display: none');
  }


() => {
    selectBox.destroy();

    expect(wwContainer).toBeEmptyDOMElement();
    expect(eventEmitter.removeEventHandler).toHaveBeenCalled();
  }


() => {
    selectBox.setLanguage('foo');

    expect(input).toHaveValue('foo');
  }


() => {
    it('should change to active state when input is focused', () => {
      input.focus();

      expect(wrapper).toHaveClass('active');
    });

    it('should change to inactive state when input is focused out', () => {
      input.focus();
      input.blur();

      expect(wrapper).not.toHaveClass('active');
    });
  }


() => {
      input.focus();

      expect(wrapper).toHaveClass('active');
    }


() => {
      input.focus();
      input.blur();

      expect(wrapper).not.toHaveClass('active');
    }


() => {
    it('should show when input is focused', () => {
      input.focus();

      expect(list).toHaveStyle('display: block');
    });

    it('should hide when input is focused out', () => {
      input.focus();
      input.blur();

      expect(list).toHaveStyle('display: none');
    });
  }


() => {
      input.focus();

      expect(list).toHaveStyle('display: block');
    }


() => {
      input.focus();
      input.blur();

      expect(list).toHaveStyle('display: none');
    }


export class Statements extends Statement {
    readonly kind:string
    readonly begin:Lex
    readonly end:Lex
    readonly statements:ReadonlyArray<Statement>
    constructor( begin:Lex, end:Lex, statements:Statement[] ){
        super()
        this.kind = "Statements"
        this.begin = begin
        this.end = end
        this.statements = statements
    }
}


/* eslint-disable */
export type Methods = {
  post: {
    status: 200

    resBody: {
      token: string
    }

    reqBody: {
      organisationSubdomain: string
      channelSubdomain: string
      userId: number
    }
  }
}


/**
 *
Returns an array of journal export job descriptions for a specified ledger.

 *
This action returns a maximum of MaxResults items, and is paginated so that
 *          you can retrieve all the items by calling ListJournalS3ExportsForLedger
 *          multiple times.

 *
This action does not return any expired export jobs. For more information, see Export job expiration in the Amazon QLDB Developer
 *          Guide.

 * @example
 * Use a bare-bones client and the command you need to make an API call.
 * ```javascript
 * import { QLDBClient, ListJournalS3ExportsForLedgerCommand } from "@aws-sdk/client-qldb"; // ES Modules import
 * // const { QLDBClient, ListJournalS3ExportsForLedgerCommand } = require("@aws-sdk/client-qldb"); // CommonJS import
 * const client = new QLDBClient(config);
 * const command = new ListJournalS3ExportsForLedgerCommand(input);
 * const response = await client.send(command);
 * ```
 *
 * @see {@link ListJournalS3ExportsForLedgerCommandInput} for command's `input` shape.
 * @see {@link ListJournalS3ExportsForLedgerCommandOutput} for command's `response` shape.
 * @see {@link QLDBClientResolvedConfig | config} for command's `input` shape.
 *
 */
export class ListJournalS3ExportsForLedgerCommand extends $Command<
  ListJournalS3ExportsForLedgerCommandInput,
  ListJournalS3ExportsForLedgerCommandOutput,
  QLDBClientResolvedConfig
> {
  // Start section: command_properties
  // End section: command_properties

  constructor(readonly input: ListJournalS3ExportsForLedgerCommandInput) {
    // Start section: command_constructor
    super();
    // End section: command_constructor
  }

  /**
   * @internal
   */
  resolveMiddleware(
    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
    configuration: QLDBClientResolvedConfig,
    options?: __HttpHandlerOptions
  ): Handler<ListJournalS3ExportsForLedgerCommandInput, ListJournalS3ExportsForLedgerCommandOutput> {
    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));

    const stack = clientStack.concat(this.middlewareStack);

    const { logger } = configuration;
    const clientName = "QLDBClient";
    const commandName = "ListJournalS3ExportsForLedgerCommand";
    const handlerExecutionContext: HandlerExecutionContext = {
      logger,
      clientName,
      commandName,
      inputFilterSensitiveLog: ListJournalS3ExportsForLedgerRequest.filterSensitiveLog,
      outputFilterSensitiveLog: ListJournalS3ExportsForLedgerResponse.filterSensitiveLog,
    };
    const { requestHandler } = configuration;
    return stack.resolve(
      (request: FinalizeHandlerArguments<any>) =>
        requestHandler.handle(request.request as __HttpRequest, options || {}),
      handlerExecutionContext
    );
  }

  private serialize(input: ListJournalS3ExportsForLedgerCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
    return serializeAws_restJson1ListJournalS3ExportsForLedgerCommand(input, context);
  }

  private deserialize(
    output: __HttpResponse,
    context: __SerdeContext
  ): Promise<ListJournalS3ExportsForLedgerCommandOutput> {
    return deserializeAws_restJson1ListJournalS3ExportsForLedgerCommand(output, context);
  }

  // Start section: command_body_extra
  // End section: command_body_extra
}


export interface ListJournalS3ExportsForLedgerCommandInput extends ListJournalS3ExportsForLedgerRequest {}


export interface ListJournalS3ExportsForLedgerCommandOutput
  extends ListJournalS3ExportsForLedgerResponse,
    __MetadataBearer {}


/**
   * @internal
   */
resolveMiddleware(
    clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>,
    configuration: QLDBClientResolvedConfig,
    options?: __HttpHandlerOptions
  ): Handler<ListJournalS3ExportsForLedgerCommandInput, ListJournalS3ExportsForLedgerCommandOutput> {
    this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));

    const stack = clientStack.concat(this.middlewareStack);

    const { logger } = configuration;
    const clientName = "QLDBClient";
    const commandName = "ListJournalS3ExportsForLedgerCommand";
    const handlerExecutionContext: HandlerExecutionContext = {
      logger,
      clientName,
      commandName,
      inputFilterSensitiveLog: ListJournalS3ExportsForLedgerRequest.filterSensitiveLog,
      outputFilterSensitiveLog: ListJournalS3ExportsForLedgerResponse.filterSensitiveLog,
    };
    const { requestHandler } = configuration;
    return stack.resolve(
      (request: FinalizeHandlerArguments<any>) =>
        requestHandler.handle(request.request as __HttpRequest, options || {}),
      handlerExecutionContext
    );
  }


private serialize(input: ListJournalS3ExportsForLedgerCommandInput, context: __SerdeContext): Promise<__HttpRequest> {
    return serializeAws_restJson1ListJournalS3ExportsForLedgerCommand(input, context);
  }


private deserialize(
    output: __HttpResponse,
    context: __SerdeContext
  ): Promise<ListJournalS3ExportsForLedgerCommandOutput> {
    return deserializeAws_restJson1ListJournalS3ExportsForLedgerCommand(output, context);
  }


/**
   *
   * Wrapper for the UnifiedNativeAdView from Google Ads SDK. All your views should be
   * wrapped inside this view always.
   *
   */
export default function NativeAdView(
    props: NativeAdViewProps
  ): JSX.Element;


/**
  * Ad Badge shows the {ad} badge on top of the ad telling the user that this is an AD.
  *
  */
export function AdBadge(props: NestedTextProps): JSX.Element;


/**
   * The title of the native ad recieved from server is renderd here.
   * You dont need to pass any values to it. It will automatically get the title from
   * context and load it.
   * You should on style it as you want.
   */
export function HeadlineView(props: TextProps): JSX.Element;


/**
   *  * The description of the native ad recieved from server is renderd here.
   */
export function TaglineView(props: TextProps): JSX.Element;


/**
   *  * The adveriser name of the native ad recieved from server is renderd here.
   */
export function AdvertiserView(props: TextProps): JSX.Element;


/**
   * If the ad or service is paid,then this view can be used to show the price.
   */
export function PriceView(props: TextProps): JSX.Element;


/**
   * Many times, the ad recieved will be from the Google Playstore or AppStore for iOS.
   * In that case, you can show the store name using this view.
   */
export function StoreView(props: TextProps): JSX.Element;


/**
   * If you want to explicitly show only Images and no video etc, use ImageView.
   */
export function ImageView(props: ImagePropsWithOptionalSource): JSX.Element;


/**
   * Icon/Logo of the adveriser shown inside this view
   */
export function IconView(props: ImagePropsWithOptionalSource): JSX.Element;


/**
   * If the ad has images or video content. It will be loaded inside the MediaView.
   */
export function NativeMediaView(props: {
    style?: StyleProp<ViewStyle>,
    onVideoStart?: () => void,
    onVideoEnd?: () => void,
    onVideoPause?: () => void,
    onVideoPlay?: () => void,
    onVideoProgress?: (progress: { duration: string, currentTime: string }) => {},
    onVideoMute?: (muted: boolean) => {},
    paused?: boolean,
    muted?: boolean

  }): JSX.Element;


/**
   * A simple button to open the adveriser website or store page etc. It is a simple
   * Text Component wrapped in a View. I dont know how to make the Touchables or Buttons
   * work since they have no effect. Native side does not recieve the call hence simple
   * Text Component is used to receive the clicks.
   */
export function CallToActionView(
    props: NestedTextProps
  ): JSX.Element;


/**
   * A Star Rating View to show the star rating for the app ads that you might recieve from
   * the server.
   */
export function StarRatingView(
    props: StarViewProps
  ): JSX.Element;


type Image = {
  /**
   * The url of the image
   */
  url: string;
  /**
   * The height of the image
   */
  height: number;
  /**
 * The width of the image
 */
  width: number;
}


type NativeAd = {
  /**
   * Title of the native ad.
   */
  headline: string;

  /**
   * Description of the native ad.
   */
  tagline: string;
  /**
   * Advertiser of the native ad.
   */
  advertiser: string;
  /**
   * If the ad is for a paid app or service, price value.
   */
  price: string;

  /**
   * Aspect ratio of the Content loaded inside MediaView.
   * You should use this to calculate the correct width and height of the MediaView.
   */
  aspectRatio: number;
  /**
   * If ad is for an app, then name of the store.
   */
  store: string;
  /**
   * Icon / Logo of the adveriser or the product advertised in ad.
   */
  icon: string;
  /**
   * An array of images along with the ad.
   */
  images: Array<Image>;
  /**
   * callToAction text value for the native ad.
   */
  callToAction: string;
  /**
   * If ad is for an app, then its rating on the respective store.
   */
  rating: number;

  /**
   * if ad has video content or not.
   */
  video: boolean;
};


type options = {
  adChoicesPlacement: {
    TOP_LEFT: number,
    TOP_RIGHT: number,
    BOTTOM_RIGHT: number,
    BOTTOM_LEFT: number
  }
}


/**
 * | Name      | Description |
| --------- | -------- |
| G | "General audiences." Content suitable for all audiences, including families and children.  |
| MA | "Mature audiences." Content suitable only for mature audiences; includes topics such as alcohol, gambling, sexual content, and weapons.  |
| PG | "Parental guidance." Content suitable for most audiences with parental guidance, including topics like non-realistic, cartoonish violence.  |
| T | "Teen." Content suitable for teen and older audiences, including topics such as general health, social networks, scary imagery, and fight sports. |
| UNSPECIFIED | Set default value to ""|
 */
type MAX_AD_CONTENT_RATING = 'G' | 'MA' | 'PG' | 'T' | 'UNSPECIFIED';


type AdManagerConfiguration = {
  maxAdContentRating: MAX_AD_CONTENT_RATING,
  tagForChildDirectedTreatment: boolean,
  tagForUnderAgeConsent: boolean,
  testDeviceIds: Array<string>
}


type ImagePropsWithOptionalSource = Omit<ImageProps, 'source'> & Partial<Pick<ImageProps, 'source'>>;


type NativeAdViewProps = {
  /**
   * When you are designing your ad, placeholders
   * for the ad will be loaded so you can easily
   * design, because for each type of ad
   * recieved from the server, not all
   * the info is available.
   */

  enableTestMode?: boolean;
  children: React.ReactNode;
  style?: StyleProp<ViewStyle>;

  /**
   * Ad Unit ID for Native ads. Remember to use only test-ids during
   * development mode or add your device to testDevices.
   */

  adUnitID: string;

  /**
   * Ads returned will be of the desired aspectRatio
   */
  mediaAspectRatio?: 'any' | 'landscape' | 'portrait' | 'square' | 'unknown'

  /**
   * Placement of AdChoicesView in any of the 4 corners of the ad
   *
   */

  adChoicesPlacement?: "topLeft" | "topRight" | "bottomLeft" | "bottomRight"

  /**
   * Under the Google EU User Consent Policy, you must make certain disclosures
   * to your users in the European Economic Area (EEA) and obtain their consent
   * to use cookies or other local storage, where legally required, and to use
   * personal data (such as AdID) to serve ads. This policy reflects the requirements
   * of the EU ePrivacy Directive and the General Data Protection Regulation (GDPR).
   *
   * You can use library such as: https://github.com/birgernass/react-native-ad-consent
   * to obtain the consent or if you are using rn-firebase you can obtain the consent from
   * there and then pass the consent to this library. If user has selected
   * non-personalized-ads then pass `true` and non-personalized ads will be shown to the user.
   *
   */
  requestNonPersonalizedAdsOnly?: boolean;

  /**
   * Set testdevices for the ad. (DEPRECATED)
   */
  videoOptions: {
    muted?: boolean,
    clickToExpand?: boolean,
    customControlsRequested?: boolean
  };

  mediationOptions: {
    nativeBanner?: boolean,
  };
  targetingOptions: {
    targets?: Array<{ key: boolean, value: string | Array<string> }>,
    categoryExclusions?: Array<string>,
    publisherId?: string,
    requestAgent?: string,
    keywords?: Array<string>,
    contentUrl?: string,
    neighboringContentUrls?: Array<string>
  };
  testDevices?: Array<string>;
  onAdOpened?: () => void;
  onAdClosed?: () => void;
  onAdLeftApplication?: () => void;
  onAdImpression?: () => void;
  onAdClicked?: () => void;
  onAdLoaded?: () => void;
  onUnifiedNativeAdLoaded?: (event: NativeAd) => {};
  onAdFailedToLoad?: (error: { message: string }) => {};
};


type SimpleViewProps = {
  style?: StyleProp<ViewStyle>;
};


type NestedTextProps = {
  style?: StyleProp<ViewStyle>;
  textStyle?: TextStyle;
  allCaps?: boolean;
  allowFontScaling?: boolean;
  buttonAndroidStyle?: {
    /**
* Only 6 digit hex colors are supported. Example: #f0f0f0
*/
    backgroundColor?: string,
    /**
* Only 6 digit hex colors are supported. Example: #f0f0f0
*/
    borderColor?: string,
    borderWidth?: number,
    borderRadius?: number,
  }
};


type StarViewProps = {
  style?: StyleProp<ViewStyle>,
  size?: number,
  iconSet?: 'Entypo' | 'EvilIcons' | 'Feather' | 'FontAwesome' | 'Foundation' | 'Ionicons' | 'MaterialIcons' | 'MaterialCommunityIcons' | 'Octicons' | 'Zocial' | 'SimpleLineIcons',
  fullIcon?: string,
  halfIcon?: string,
  emptyIcon?: string,
  fullIconColor?: string,
  halfIconColor?: string,
  emptyIconColor?: string
};


/* Moralis init code */
async function init() {
  return Moralis.start({
    serverUrl: process.env.MORALIS_RPC_PROVIDER,
    appId: process.env.MORALIS_APP_ID,
  })
}


export async function accountLifetimeYield(
  account: string,
  currentBalance: string
): Promise<number> {
  await init()

  const zeroFromAddress = '0x0000000000000000000000000000000000000000'
  const accountLower = account.toLowerCase()

  const recvQuery = new Moralis.Query('XUSDProxyTransfer').equalTo(
    'to',
    accountLower
  )
  const sentQuery = new Moralis.Query('XUSDProxyTransfer').equalTo(
    'from',
    accountLower
  )
  const results = await Moralis.Query.or(recvQuery, sentQuery).find()

  const totalMinted = results.reduce((prev, cur) => {
    let valueWithSign = cur.get('value')
    if (cur.get('from') == accountLower) {
      // debit transfer from account
      valueWithSign = '-' + valueWithSign
    }
    return prev.add(BigNumber.from(valueWithSign))
  }, BigNumber.from('0'))

  const lifetimeYield = BigNumber.from(
    ethers.utils.parseUnits(currentBalance, 18)
  ).sub(totalMinted)

  return parseFloat(ethers.utils.formatUnits(lifetimeYield, 18))
}


export async function totalSupplyEvents(): Promise<any[]> {
  await init()

  const XUSDProxyTotalSupplyUpdated = Moralis.Object.extend(
    'XUSDProxyTotalSupplyUpdated'
  )
  const query = new Moralis.Query(XUSDProxyTotalSupplyUpdated).greaterThan(
    'block_timestamp',
    moment().subtract(30, 'days').toDate()
  )
  const results = await query.find()

  return results
}


(prev, cur) => {
    let valueWithSign = cur.get('value')
    if (cur.get('from') == accountLower) {
      // debit transfer from account
      valueWithSign = '-' + valueWithSign
    }
    return prev.add(BigNumber.from(valueWithSign))
  }


(
    {
      checkboxClassNames,
      unCheckedBgClassName = 'bg-gray-50',
      checkedBgClassName = 'bg-primary-hover',
      tickCheckedClassName = 'text-white',
      value,
      label,
      labelPosition = 'right',
      labelClassName,
      containerClassName,
      name,
      onChange,
      onBlur,
      field,
      error,
      form,
    },
    ref,
  ) => {
    const [isFocused, setIsFocused] = useState(false);
    const [checkboxId] = useId(1, 'checkbox');

    const {
      formikCompatibleOnBlur,
      formikCompatibleError,
      formikCompatibleName,
      formikCompatibleOnChange,
      formikCompatibleValue,
    } = useBooleanInputValues({
      value,
      onChange,
      onBlur,
      error,
      field,
      form,
      name,
    });

    const { defaultContainerClassName, defaultLabelClassName } = useMemo(() => {
      switch (labelPosition) {
        case 'top':
          return {
            defaultContainerClassName: 'label-top-container',
            defaultLabelClassName: 'label-top',
          };
        case 'right':
          return {
            defaultContainerClassName: 'label-right-container',
            defaultLabelClassName: 'label-right',
          };
        case 'bottom':
          return {
            defaultContainerClassName: 'label-bottom-container',
            defaultLabelClassName: 'label-bottom',
          };
        case 'left':
          return {
            defaultContainerClassName: 'label-left-container',
            defaultLabelClassName: 'label-left',
          };
        default:
          return {
            defaultContainerClassName: 'label-top-container',
            defaultLabelClassName: 'label-top',
          };
      }
    }, [labelPosition]);

    const setFocusTrue = useCallback(() => {
      setIsFocused(true);
    }, []);

    const setFocusFalse = useCallback(() => {
      setIsFocused(false);
    }, []);

    return (
      <label
        htmlFor={`${checkboxId}${formikCompatibleName || ''}`}


() => {
      switch (labelPosition) {
        case 'top':
          return {
            defaultContainerClassName: 'label-top-container',
            defaultLabelClassName: 'label-top',
          };
        case 'right':
          return {
            defaultContainerClassName: 'label-right-container',
            defaultLabelClassName: 'label-right',
          };
        case 'bottom':
          return {
            defaultContainerClassName: 'label-bottom-container',
            defaultLabelClassName: 'label-bottom',
          };
        case 'left':
          return {
            defaultContainerClassName: 'label-left-container',
            defaultLabelClassName: 'label-left',
          };
        default:
          return {
            defaultContainerClassName: 'label-top-container',
            defaultLabelClassName: 'label-top',
          };
      }
    }


() => {
      setIsFocused(true);
    }


() => {
      setIsFocused(false);
    }


type CheckBoxProps = {
  checkboxClassNames?: string;
  tickCheckedClassName?: string;
  value?: boolean;
  containerClassName?: string;
  label?: string;
  labelClassName?: string;
  labelPosition?: 'top' | 'right' | 'bottom' | 'left';
  onChange?: (value: boolean) => void;
  onBlur?: (event: React.FocusEvent<HTMLInputElement>) => void;
  unCheckedBgClassName?: string;
  checkedBgClassName?: string;
  name?: string;
  field?: BooleanFieldInputProps<HTMLInputElement>;
  form?: BooleanFormikProps;
  error?: string;
};


classNames(defaultContainerClassName, containerClassName)


classNames(defaultLabelClassName, labelClassName)


classNames(
            'checkbox',
            {
              [unCheckedBgClassName]: !value,
              [checkedBgClassName]: value,

              'checkbox-focus': isFocused,


() => {
	it("should not consider build numbers when comparing versions", () => {
		assert.equal(versionIsAtLeast("1.2.3", "1.2.3"), true);
		assert.equal(versionIsAtLeast("1.2.3+012345", "1.2.3"), true);
	});
	it("should consider pre-release versions older than release versions", () => {
		assert.equal(versionIsAtLeast("1.2.3-alpha", "1.2.3"), false);
		assert.equal(versionIsAtLeast("1.2.3-alpha+012345", "1.2.3"), false);
	});
	it("should compare segments as individual numbers, not decimals", () => {
		assert.equal(versionIsAtLeast("1.9.0", "1.10.0"), false);
	});
	it("should return the correct result for some real world tests", () => {
		assert.equal(versionIsAtLeast("1.2.0", "1.18.1"), false);
		assert.equal(versionIsAtLeast("1.18.0", "1.18.1"), false);
		assert.equal(versionIsAtLeast("1.18.1", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.0", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.0-dev.0.0", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.0-dev.5.0", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.0-dev.7.0", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.1-dev.0.0", "1.19.0"), true);
		assert.equal(versionIsAtLeast("0.10.2-pre.119", "0.10.2"), false);
		assert.equal(versionIsAtLeast("0.10.1", "0.10.2-a"), false);
		assert.equal(versionIsAtLeast("0.10.1-pre.119", "0.10.2-a"), false);
		assert.equal(versionIsAtLeast("0.10.2-pre.119", "0.10.2-a"), true);
		assert.equal(versionIsAtLeast("0.10.3-pre.119", "0.10.2-a"), true);
		assert.equal(versionIsAtLeast("0.10.2-alpha.1", "0.10.2-a"), true);
		assert.equal(versionIsAtLeast("0.10.2-beta.1", "0.10.2-a"), true);
		assert.equal(versionIsAtLeast("2.2.0", "2.2.1-edge"), false);
		assert.equal(versionIsAtLeast("2.2.1-dev", "2.2.1-edge"), false);
		assert.equal(versionIsAtLeast("2.2.1-dev.1", "2.2.1-edge"), false);
		assert.equal(versionIsAtLeast("2.2.1-edge", "2.2.1-edge"), true);
		assert.equal(versionIsAtLeast("2.2.1-edge.foo", "2.2.1-edge"), true);
	});
}


() => {
		assert.equal(versionIsAtLeast("1.2.3", "1.2.3"), true);
		assert.equal(versionIsAtLeast("1.2.3+012345", "1.2.3"), true);
	}


() => {
		assert.equal(versionIsAtLeast("1.2.3-alpha", "1.2.3"), false);
		assert.equal(versionIsAtLeast("1.2.3-alpha+012345", "1.2.3"), false);
	}


() => {
		assert.equal(versionIsAtLeast("1.9.0", "1.10.0"), false);
	}


() => {
		assert.equal(versionIsAtLeast("1.2.0", "1.18.1"), false);
		assert.equal(versionIsAtLeast("1.18.0", "1.18.1"), false);
		assert.equal(versionIsAtLeast("1.18.1", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.0", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.0-dev.0.0", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.0-dev.5.0", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.0-dev.7.0", "1.18.1"), true);
		assert.equal(versionIsAtLeast("1.19.1-dev.0.0", "1.19.0"), true);
		assert.equal(versionIsAtLeast("0.10.2-pre.119", "0.10.2"), false);
		assert.equal(versionIsAtLeast("0.10.1", "0.10.2-a"), false);
		assert.equal(versionIsAtLeast("0.10.1-pre.119", "0.10.2-a"), false);
		assert.equal(versionIsAtLeast("0.10.2-pre.119", "0.10.2-a"), true);
		assert.equal(versionIsAtLeast("0.10.3-pre.119", "0.10.2-a"), true);
		assert.equal(versionIsAtLeast("0.10.2-alpha.1", "0.10.2-a"), true);
		assert.equal(versionIsAtLeast("0.10.2-beta.1", "0.10.2-a"), true);
		assert.equal(versionIsAtLeast("2.2.0", "2.2.1-edge"), false);
		assert.equal(versionIsAtLeast("2.2.1-dev", "2.2.1-edge"), false);
		assert.equal(versionIsAtLeast("2.2.1-dev.1", "2.2.1-edge"), false);
		assert.equal(versionIsAtLeast("2.2.1-edge", "2.2.1-edge"), true);
		assert.equal(versionIsAtLeast("2.2.1-edge.foo", "2.2.1-edge"), true);
	}


() => {
	it("should consider build metadata newer than without", () => {
		assert.equal(pubVersionIsAtLeast("1.2.3+012345", "1.2.3"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3", "1.2.3+012345"), false);
	});
	it("should sort build metadata the same way as pre-release", () => {
		assert.equal(pubVersionIsAtLeast("1.2.3+123", "1.2.3+122"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3+122", "1.2.3+123"), false);
	});
	it("should sort pre-release before build metadata", () => {
		assert.equal(pubVersionIsAtLeast("1.2.3-123", "1.2.3+122"), false);
		assert.equal(pubVersionIsAtLeast("1.2.3+122", "1.2.3-123"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3-123+122", "1.2.3-122+123"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3-122+123", "1.2.3-123+122"), false);
	});
	it("should sort by build metadata if pre-release is equal", () => {
		assert.equal(pubVersionIsAtLeast("1.2.3-123+123", "1.2.3-123+122"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3-123+122", "1.2.3-123+123"), false);
	});
}


() => {
		assert.equal(pubVersionIsAtLeast("1.2.3+012345", "1.2.3"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3", "1.2.3+012345"), false);
	}


() => {
		assert.equal(pubVersionIsAtLeast("1.2.3+123", "1.2.3+122"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3+122", "1.2.3+123"), false);
	}


() => {
		assert.equal(pubVersionIsAtLeast("1.2.3-123", "1.2.3+122"), false);
		assert.equal(pubVersionIsAtLeast("1.2.3+122", "1.2.3-123"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3-123+122", "1.2.3-122+123"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3-122+123", "1.2.3-123+122"), false);
	}


() => {
		assert.equal(pubVersionIsAtLeast("1.2.3-123+123", "1.2.3-123+122"), true);
		assert.equal(pubVersionIsAtLeast("1.2.3-123+122", "1.2.3-123+123"), false);
	}


() => {
	it("should consider missing versions as unstable", () => {
		assert.equal(isStableSdk(), false);
		assert.equal(isStableSdk(undefined), false);
	});
	it("should consider anything without a hyphen as stable", () => {
		assert.equal(isStableSdk("1.0.0"), true);
		assert.equal(isStableSdk("1.2.0"), true);
		assert.equal(isStableSdk("1.2.3"), true);
	});
	it("should consider anything with a hyphen as unstable", () => {
		assert.equal(isStableSdk("1.0.0-dev"), false);
		assert.equal(isStableSdk("1.2.0-beta"), false);
		assert.equal(isStableSdk("1.2.3-alpha.3"), false);
		assert.equal(isStableSdk("0.2.2-pre.55"), false);
		assert.equal(isStableSdk("2.0.0-dev.37.0.flutter-7328726088"), false);
	});
}


() => {
		assert.equal(isStableSdk(), false);
		assert.equal(isStableSdk(undefined), false);
	}


() => {
		assert.equal(isStableSdk("1.0.0"), true);
		assert.equal(isStableSdk("1.2.0"), true);
		assert.equal(isStableSdk("1.2.3"), true);
	}


() => {
		assert.equal(isStableSdk("1.0.0-dev"), false);
		assert.equal(isStableSdk("1.2.0-beta"), false);
		assert.equal(isStableSdk("1.2.3-alpha.3"), false);
		assert.equal(isStableSdk("0.2.2-pre.55"), false);
		assert.equal(isStableSdk("2.0.0-dev.37.0.flutter-7328726088"), false);
	}


() => {
	it("should consider Dart SDK to not be from Flutter", function () {
		if (!process.env.DART_PATH) {
			this.skip();
			return;
		}

		assert.equal(isDartSdkFromFlutter(process.env.DART_PATH), false);
	});
	it("should consider Flutter's Dart SDK to be from Flutter", function () {
		if (!process.env.FLUTTER_PATH) {
			this.skip();
			return;
		}

		assert.equal(isDartSdkFromFlutter(path.join(process.env.FLUTTER_PATH, "bin", "cache", "dart-sdk")), true);
	});
}


() => {
	const redPrefix = "\u001b[38;5;1m";
	const reset = "\u001b[39;49m";
	it("should work with strings with no whitespace", () => {
		assert.equal(applyColor("This is a test", red), `${redPrefix}This is a test${reset}`);
	});
	it("should work with leading whitespace", () => {
		assert.equal(applyColor("\n\n  This is a test", red), `\n\n  ${redPrefix}This is a test${reset}`);
	});
	it("should work with trailing whitespace", () => {
		assert.equal(applyColor("This is a test  \n\n", red), `${redPrefix}This is a test${reset}  \n\n`);
	});
	it("should work with leading and trailing whitespace", () => {
		assert.equal(applyColor("\n \n This is a test \n \n", red), `\n \n ${redPrefix}This is a test${reset} \n \n`);
	});
}


() => {
		assert.equal(applyColor("This is a test", red), `${redPrefix}This is a test${reset}`);
	}


() => {
		assert.equal(applyColor("\n\n  This is a test", red), `\n\n  ${redPrefix}This is a test${reset}`);
	}


() => {
		assert.equal(applyColor("This is a test  \n\n", red), `${redPrefix}This is a test${reset}  \n\n`);
	}


() => {
		assert.equal(applyColor("\n \n This is a test \n \n", red), `\n \n ${redPrefix}This is a test${reset} \n \n`);
	}


export declare function animationFrames(timestampProvider?: TimestampProvider): Observable<{
    timestamp: number;
    elapsed: number;
}>;


export declare function bindCallback(callbackFunc: (...args: any[]) => void, resultSelector: (...args: any[]) => any, scheduler?: SchedulerLike): (...args: any[]) => Observable<any>;


export declare function bindCallback<A extends readonly unknown[], R extends readonly unknown[]>(callbackFunc: (...args: [...A, (...res: R) => void]) => void, schedulerLike?: SchedulerLike): (...arg: A) => Observable<R extends [] ? void : R extends [any] ? R[0] : R>;


export declare function bindNodeCallback(callbackFunc: (...args: any[]) => void, resultSelector: (...args: any[]) => any, scheduler?: SchedulerLike): (...args: any[]) => Observable<any>;


export declare function bindNodeCallback<A extends readonly unknown[], R extends readonly unknown[]>(callbackFunc: (...args: [...A, (err: any, ...res: R) => void]) => void, schedulerLike?: SchedulerLike): (...arg: A) => Observable<R extends [] ? void : R extends [any] ? R[0] : R>;


export declare function combineLatest(sources: []): Observable<never>;


export declare function combineLatest<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<A>;


export declare function combineLatest<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>;


export declare function combineLatest(sourcesObject: {}): Observable<never>;


export declare function combineLatest<T>(sourcesObject: T): Observable<{
    [K in keyof T]: ObservedValueOf<T[K]>;
}>;


export declare function combineLatest<O1 extends ObservableInput<any>, R>(sources: [O1], resultSelector: (v1: ObservedValueOf<O1>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, R>(sources: [O1, O2], resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, R>(sources: [O1, O2, O3], resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, R>(sources: [O1, O2, O3, O4], resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, R>(sources: [O1, O2, O3, O4, O5], resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>, R>(sources: [O1, O2, O3, O4, O5, O6], resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>, v6: ObservedValueOf<O6>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O extends ObservableInput<any>, R>(sources: O[], resultSelector: (...args: ObservedValueOf<O>[]) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, R>(v1: O1, resultSelector: (v1: ObservedValueOf<O1>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, R>(v1: O1, v2: O2, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, R>(v1: O1, v2: O2, v3: O3, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, R>(v1: O1, v2: O2, v3: O3, v4: O4, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, R>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>, R>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, v6: O6, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>, v6: ObservedValueOf<O6>) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O1 extends ObservableInput<any>>(sources: [O1], scheduler: SchedulerLike): Observable<[ObservedValueOf<O1>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>>(sources: [O1, O2], scheduler: SchedulerLike): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>>(sources: [O1, O2, O3], scheduler: SchedulerLike): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>>(sources: [O1, O2, O3, O4], scheduler: SchedulerLike): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>>(sources: [O1, O2, O3, O4, O5], scheduler: SchedulerLike): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>, ObservedValueOf<O5>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>>(sources: [O1, O2, O3, O4, O5, O6], scheduler: SchedulerLike): Observable<[
    ObservedValueOf<O1>,
    ObservedValueOf<O2>,
    ObservedValueOf<O3>,
    ObservedValueOf<O4>,
    ObservedValueOf<O5>,
    ObservedValueOf<O6>
]>;


export declare function combineLatest<O extends ObservableInput<any>>(sources: O[], scheduler: SchedulerLike): Observable<ObservedValueOf<O>[]>;


export declare function combineLatest<O1 extends ObservableInput<any>>(v1: O1, scheduler?: SchedulerLike): Observable<[ObservedValueOf<O1>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>>(v1: O1, v2: O2, scheduler?: SchedulerLike): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, scheduler?: SchedulerLike): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4, scheduler?: SchedulerLike): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, scheduler?: SchedulerLike): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>, ObservedValueOf<O5>]>;


export declare function combineLatest<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, v6: O6, scheduler?: SchedulerLike): Observable<[
    ObservedValueOf<O1>,
    ObservedValueOf<O2>,
    ObservedValueOf<O3>,
    ObservedValueOf<O4>,
    ObservedValueOf<O5>,
    ObservedValueOf<O6>
]>;


export declare function combineLatest<O extends ObservableInput<any>>(...observables: O[]): Observable<any[]>;


export declare function combineLatest<O extends ObservableInput<any>, R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): Observable<R>;


export declare function combineLatest<O extends ObservableInput<any>, R>(array: O[], resultSelector: (...values: ObservedValueOf<O>[]) => R, scheduler?: SchedulerLike): Observable<R>;


export declare function combineLatest<O extends ObservableInput<any>>(...observables: Array<O | SchedulerLike>): Observable<any[]>;


export declare function combineLatest<O extends ObservableInput<any>, R>(...observables: Array<O | ((...values: ObservedValueOf<O>[]) => R) | SchedulerLike>): Observable<R>;


export declare function combineLatest<R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R) | SchedulerLike>): Observable<R>;


export declare function concat<O1 extends ObservableInput<any>>(v1: O1, scheduler: SchedulerLike): Observable<ObservedValueOf<O1>>;


export declare function concat<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>>(v1: O1, v2: O2, scheduler: SchedulerLike): Observable<ObservedValueOf<O1> | ObservedValueOf<O2>>;


export declare function concat<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, scheduler: SchedulerLike): Observable<ObservedValueOf<O1> | ObservedValueOf<O2> | ObservedValueOf<O3>>;


export declare function concat<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4, scheduler: SchedulerLike): Observable<ObservedValueOf<O1> | ObservedValueOf<O2> | ObservedValueOf<O3> | ObservedValueOf<O4>>;


export declare function concat<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, scheduler: SchedulerLike): Observable<ObservedValueOf<O1> | ObservedValueOf<O2> | ObservedValueOf<O3> | ObservedValueOf<O4> | ObservedValueOf<O5>>;


export declare function concat<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, v6: O6, scheduler: SchedulerLike): Observable<ObservedValueOf<O1> | ObservedValueOf<O2> | ObservedValueOf<O3> | ObservedValueOf<O4> | ObservedValueOf<O5> | ObservedValueOf<O6>>;


export declare function concat<A extends ObservableInput<any>[]>(...observables: A): Observable<ObservedValueUnionFromArray<A>>;


export declare function defer<R extends ObservableInput<any>>(observableFactory: () => R): Observable<ObservedValueOf<R>>;


export declare function empty(scheduler?: SchedulerLike): Observable<never>;


export declare function firstValueFrom<T>(source: Observable<T>): Promise<T>;


export declare function forkJoin(sources: []): Observable<never>;


export declare function forkJoin<A extends readonly unknown[]>(sources: readonly [...ObservableInputTuple<A>]): Observable<A>;


export declare function forkJoin<A extends readonly unknown[]>(...sources: [...ObservableInputTuple<A>]): Observable<A>;


export declare function forkJoin(sourcesObject: {}): Observable<never>;


export declare function forkJoin<T>(sourcesObject: T): Observable<{
    [K in keyof T]: ObservedValueOf<T[K]>;
}>;


export declare function forkJoin(...args: Array<ObservableInput<any> | ((...args: any[]) => any)>): Observable<any>;


export declare function from<O extends ObservableInput<any>>(input: O): Observable<ObservedValueOf<O>>;


export declare function from<O extends ObservableInput<any>>(input: O, scheduler: SchedulerLike): Observable<ObservedValueOf<O>>;


export declare function fromEvent<T>(target: FromEventTarget<T>, eventName: string): Observable<T>;


export declare function fromEvent<T>(target: FromEventTarget<T>, eventName: string, resultSelector?: (...args: any[]) => T): Observable<T>;


export declare function fromEvent<T>(target: FromEventTarget<T>, eventName: string, options?: EventListenerOptions): Observable<T>;


export declare function fromEvent<T>(target: FromEventTarget<T>, eventName: string, options: EventListenerOptions, resultSelector: (...args: any[]) => T): Observable<T>;


export declare function fromEventPattern<T>(addHandler: (handler: NodeEventHandler) => any, removeHandler?: (handler: NodeEventHandler, signal?: any) => void): Observable<T>;


export declare function fromEventPattern<T>(addHandler: (handler: NodeEventHandler) => any, removeHandler?: (handler: NodeEventHandler, signal?: any) => void, resultSelector?: (...args: any[]) => T): Observable<T>;


export declare function generate<T, S>(initialState: S, condition: ConditionFunc<S>, iterate: IterateFunc<S>, resultSelector: ResultFunc<S, T>, scheduler?: SchedulerLike): Observable<T>;


export declare function generate<S>(initialState: S, condition: ConditionFunc<S>, iterate: IterateFunc<S>, scheduler?: SchedulerLike): Observable<S>;


export declare function generate<S>(options: GenerateBaseOptions<S>): Observable<S>;


export declare function generate<T, S>(options: GenerateOptions<T, S>): Observable<T>;


export declare function identity<T>(x: T): T;


export declare function iif<T>(condition: () => true, trueResult: ObservableInput<T>, falseResult: ObservableInput<any>): Observable<T>;


export declare function iif<F>(condition: () => false, trueResult: ObservableInput<any>, falseResult: ObservableInput<F>): Observable<F>;


export declare function iif<T, F>(condition: () => boolean, trueResult: ObservableInput<T>, falseResult: ObservableInput<F>): Observable<T | F>;


export declare function interval(period?: number, scheduler?: SchedulerLike): Observable<number>;


export declare function isObservable<T>(obj: any): obj is Observable<T>;


export declare function lastValueFrom<T>(source: Observable<T>): Promise<T>;


export declare function merge<T>(v1: ObservableInput<T>, scheduler: SchedulerLike): Observable<T>;


export declare function merge<T>(v1: ObservableInput<T>, concurrent: number, scheduler: SchedulerLike): Observable<T>;


export declare function merge<T, T2>(v1: ObservableInput<T>, v2: ObservableInput<T2>, scheduler: SchedulerLike): Observable<T | T2>;


export declare function merge<T, T2>(v1: ObservableInput<T>, v2: ObservableInput<T2>, concurrent: number, scheduler: SchedulerLike): Observable<T | T2>;


export declare function merge<T, T2, T3>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, scheduler: SchedulerLike): Observable<T | T2 | T3>;


export declare function merge<T, T2, T3>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, concurrent: number, scheduler: SchedulerLike): Observable<T | T2 | T3>;


export declare function merge<T, T2, T3, T4>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4>;


export declare function merge<T, T2, T3, T4>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, concurrent: number, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4>;


export declare function merge<T, T2, T3, T4, T5>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5>;


export declare function merge<T, T2, T3, T4, T5>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, concurrent: number, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5>;


export declare function merge<T, T2, T3, T4, T5, T6>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5 | T6>;


export declare function merge<T, T2, T3, T4, T5, T6>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, concurrent: number, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5 | T6>;


export declare function merge<T>(v1: ObservableInput<T>): Observable<T>;


export declare function merge<T>(v1: ObservableInput<T>, concurrent: number): Observable<T>;


export declare function merge<T, T2>(v1: ObservableInput<T>, v2: ObservableInput<T2>): Observable<T | T2>;


export declare function merge<T, T2>(v1: ObservableInput<T>, v2: ObservableInput<T2>, concurrent: number): Observable<T | T2>;


export declare function merge<T, T2, T3>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>): Observable<T | T2 | T3>;


export declare function merge<T, T2, T3>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, concurrent: number): Observable<T | T2 | T3>;


export declare function merge<T, T2, T3, T4>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>): Observable<T | T2 | T3 | T4>;


export declare function merge<T, T2, T3, T4>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, concurrent: number): Observable<T | T2 | T3 | T4>;


export declare function merge<T, T2, T3, T4, T5>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>): Observable<T | T2 | T3 | T4 | T5>;


export declare function merge<T, T2, T3, T4, T5>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, concurrent: number): Observable<T | T2 | T3 | T4 | T5>;


export declare function merge<T, T2, T3, T4, T5, T6>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>): Observable<T | T2 | T3 | T4 | T5 | T6>;


export declare function merge<T, T2, T3, T4, T5, T6>(v1: ObservableInput<T>, v2: ObservableInput<T2>, v3: ObservableInput<T3>, v4: ObservableInput<T4>, v5: ObservableInput<T5>, v6: ObservableInput<T6>, concurrent: number): Observable<T | T2 | T3 | T4 | T5 | T6>;


export declare function merge<T>(...observables: (ObservableInput<T> | number)[]): Observable<T>;


export declare function merge<T>(...observables: (ObservableInput<T> | SchedulerLike | number)[]): Observable<T>;


export declare function merge<T, R>(...observables: (ObservableInput<any> | number)[]): Observable<R>;


export declare function merge<T, R>(...observables: (ObservableInput<any> | SchedulerLike | number)[]): Observable<R>;


export declare function never(): Observable<never>;


export declare function noop(): void;


export declare function of(scheduler: SchedulerLike): Observable<never>;


export declare function of<T>(a: T, scheduler: SchedulerLike): Observable<T>;


export declare function of<T, T2>(a: T, b: T2, scheduler: SchedulerLike): Observable<T | T2>;


export declare function of<T, T2, T3>(a: T, b: T2, c: T3, scheduler: SchedulerLike): Observable<T | T2 | T3>;


export declare function of<T, T2, T3, T4>(a: T, b: T2, c: T3, d: T4, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4>;


export declare function of<T, T2, T3, T4, T5>(a: T, b: T2, c: T3, d: T4, e: T5, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5>;


export declare function of<T, T2, T3, T4, T5, T6>(a: T, b: T2, c: T3, d: T4, e: T5, f: T6, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5 | T6>;


export declare function of<T, T2, T3, T4, T5, T6, T7>(a: T, b: T2, c: T3, d: T4, e: T5, f: T6, g: T7, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5 | T6 | T7>;


export declare function of<T, T2, T3, T4, T5, T6, T7, T8>(a: T, b: T2, c: T3, d: T4, e: T5, f: T6, g: T7, h: T8, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8>;


export declare function of<T, T2, T3, T4, T5, T6, T7, T8, T9>(a: T, b: T2, c: T3, d: T4, e: T5, f: T6, g: T7, h: T8, i: T9, scheduler: SchedulerLike): Observable<T | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9>;


export declare function of(): Observable<never>;


export declare function of<T>(): Observable<T>;


export declare function of<T>(value: T): Observable<T>;


export declare function of<T, U>(value1: T, value2: U): Observable<T | U>;


export declare function of<T, U, V>(value1: T, value2: U, value3: V): Observable<T | U | V>;


export declare function of<A extends Array<any>>(...args: A): Observable<ValueFromArray<A>>;


export declare function onErrorResumeNext(): Observable<never>;


export declare function onErrorResumeNext<O extends ObservableInput<any>>(arrayOfSources: O[]): Observable<ObservedValueOf<O>>;


export declare function onErrorResumeNext<A extends ObservableInput<any>[]>(...sources: A): Observable<ObservedValueUnionFromArray<A>>;


export declare function pairs<T>(obj: Record<string, T> | ArrayLike<T>, scheduler?: SchedulerLike): Observable<[string, T]>;


export declare function partition<T>(source: ObservableInput<T>, predicate: (value: T, index: number) => boolean, thisArg?: any): [Observable<T>, Observable<T>];


export declare function pipe<T>(): UnaryFunction<T, T>;


export declare function pipe<T, A>(fn1: UnaryFunction<T, A>): UnaryFunction<T, A>;


export declare function pipe<T, A, B>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>): UnaryFunction<T, B>;


export declare function pipe<T, A, B, C>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>): UnaryFunction<T, C>;


export declare function pipe<T, A, B, C, D>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>): UnaryFunction<T, D>;


export declare function pipe<T, A, B, C, D, E>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>): UnaryFunction<T, E>;


export declare function pipe<T, A, B, C, D, E, F>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>): UnaryFunction<T, F>;


export declare function pipe<T, A, B, C, D, E, F, G>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>): UnaryFunction<T, G>;


export declare function pipe<T, A, B, C, D, E, F, G, H>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>): UnaryFunction<T, H>;


export declare function pipe<T, A, B, C, D, E, F, G, H, I>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>, fn9: UnaryFunction<H, I>): UnaryFunction<T, I>;


export declare function pipe<T, A, B, C, D, E, F, G, H, I>(fn1: UnaryFunction<T, A>, fn2: UnaryFunction<A, B>, fn3: UnaryFunction<B, C>, fn4: UnaryFunction<C, D>, fn5: UnaryFunction<D, E>, fn6: UnaryFunction<E, F>, fn7: UnaryFunction<F, G>, fn8: UnaryFunction<G, H>, fn9: UnaryFunction<H, I>, ...fns: UnaryFunction<any, any>[]): UnaryFunction<T, {}>;


export declare function race<A extends ObservableInput<any>[]>(observables: A): Observable<ObservedValueUnionFromArray<A>>;


export declare function race<A extends ObservableInput<any>[]>(...observables: A): Observable<ObservedValueUnionFromArray<A>>;


export declare function range(start: number, count?: number): Observable<number>;


export declare function range(start: number, count: number | undefined, scheduler: SchedulerLike): Observable<number>;


export declare function scheduled<T>(input: ObservableInput<T>, scheduler: SchedulerLike): Observable<T>;


export declare function throwError(errorFactory: () => any): Observable<never>;


export declare function throwError(error: any): Observable<never>;


export declare function throwError(errorOrErrorFactory: any, scheduler: SchedulerLike): Observable<never>;


export declare function timer(due: number | Date, scheduler?: SchedulerLike): Observable<0>;


export declare function timer(startDue: number | Date, intervalDuration: number, scheduler?: SchedulerLike): Observable<number>;


export declare function timer(dueTime: number | Date, unused: undefined, scheduler?: SchedulerLike): Observable<0>;


export declare function using<T>(resourceFactory: () => Unsubscribable | void, observableFactory: (resource: Unsubscribable | void) => ObservableInput<T> | void): Observable<T>;


export declare function zip<O1 extends ObservableInput<any>, R>(v1: O1, resultSelector: (v1: ObservedValueOf<O1>) => R): Observable<R>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, R>(v1: O1, v2: O2, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>) => R): Observable<R>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, R>(v1: O1, v2: O2, v3: O3, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>) => R): Observable<R>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, R>(v1: O1, v2: O2, v3: O3, v4: O4, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>) => R): Observable<R>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, R>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>) => R): Observable<R>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>, R>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, v6: O6, resultSelector: (v1: ObservedValueOf<O1>, v2: ObservedValueOf<O2>, v3: ObservedValueOf<O3>, v4: ObservedValueOf<O4>, v5: ObservedValueOf<O5>, v6: ObservedValueOf<O6>) => R): Observable<R>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>>(v1: O1, v2: O2): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>]>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>]>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>]>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5): Observable<[ObservedValueOf<O1>, ObservedValueOf<O2>, ObservedValueOf<O3>, ObservedValueOf<O4>, ObservedValueOf<O5>]>;


export declare function zip<O1 extends ObservableInput<any>, O2 extends ObservableInput<any>, O3 extends ObservableInput<any>, O4 extends ObservableInput<any>, O5 extends ObservableInput<any>, O6 extends ObservableInput<any>>(v1: O1, v2: O2, v3: O3, v4: O4, v5: O5, v6: O6): Observable<[
    ObservedValueOf<O1>,
    ObservedValueOf<O2>,
    ObservedValueOf<O3>,
    ObservedValueOf<O4>,
    ObservedValueOf<O5>,
    ObservedValueOf<O6>
]>;


export declare function zip<O extends ObservableInput<any>>(array: O[]): Observable<ObservedValueOf<O>[]>;


export declare function zip<R>(array: ObservableInput<any>[]): Observable<R>;


export declare function zip<O extends ObservableInput<any>, R>(array: O[], resultSelector: (...values: ObservedValueOf<O>[]) => R): Observable<R>;


export declare function zip<R>(array: ObservableInput<any>[], resultSelector: (...values: any[]) => R): Observable<R>;


export declare function zip<O extends ObservableInput<any>>(...observables: O[]): Observable<ObservedValueOf<O>[]>;


export declare function zip<O extends ObservableInput<any>, R>(...observables: Array<O | ((...values: ObservedValueOf<O>[]) => R)>): Observable<R>;


export declare function zip<R>(...observables: Array<ObservableInput<any> | ((...values: Array<any>) => R)>): Observable<R>;


export declare class AsyncSubject<T> extends Subject<T> {
    protected _checkFinalizedStatuses(subscriber: Subscriber<T>): void;
    complete(): void;
    next(value: T): void;
}


export declare class BehaviorSubject<T> extends Subject<T> {
    get value(): T;
    constructor(_value: T);
    protected _subscribe(subscriber: Subscriber<T>): Subscription;
    getValue(): T;
    next(value: T): void;
}


export declare class ConnectableObservable<T> extends Observable<T> {
    protected _connection: Subscription | null;
    protected _refCount: number;
    protected _subject: Subject<T> | null;
    source: Observable<T>;
    protected subjectFactory: () => Subject<T>;
    constructor(source: Observable<T>, subjectFactory: () => Subject<T>);
    protected _subscribe(subscriber: Subscriber<T>): Subscription;
    protected _teardown(): void;
    connect(): Subscription;
    protected getSubject(): Subject<T>;
    refCount(): Observable<T>;
}


export declare class Notification<T> {
    readonly error?: any;
    readonly hasValue: boolean;
    readonly kind: 'N' | 'E' | 'C';
    readonly value?: T | undefined;
    constructor(kind: 'C');
    constructor(kind: 'E', value: undefined, error: any);
    constructor(kind: 'N', value?: T);
    accept(next: (value: T) => void, error: (err: any) => void, complete: () => void): void;
    accept(next: (value: T) => void, error: (err: any) => void): void;
    accept(next: (value: T) => void): void;
    accept(observer: PartialObserver<T>): void;
    do(next: (value: T) => void, error: (err: any) => void, complete: () => void): void;
    do(next: (value: T) => void, error: (err: any) => void): void;
    do(next: (value: T) => void): void;
    observe(observer: PartialObserver<T>): void;
    toObservable(): Observable<T>;
    static createComplete(): Notification<never> & CompleteNotification;
    static createError(err?: any): Notification<never> & ErrorNotification;
    static createNext<T>(value: T): Notification<T> & NextNotification<T>;
}


export declare class Observable<T> implements Subscribable<T> {
    protected operator: Operator<any, T> | undefined;
    protected source: Observable<any> | undefined;
    constructor(subscribe?: (this: Observable<T>, subscriber: Subscriber<T>) => TeardownLogic);
    protected _subscribe(subscriber: Subscriber<any>): TeardownLogic;
    protected _trySubscribe(sink: Subscriber<T>): TeardownLogic;
    forEach(next: (value: T) => void): Promise<void>;
    forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;
    protected lift<R>(operator?: Operator<T, R>): Observable<R>;
    pipe(): Observable<T>;
    pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;
    pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;
    pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;
    pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;
    pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;
    pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;
    pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;
    pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;
    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;
    pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<unknown>;
    subscribe(observer?: PartialObserver<T>): Subscription;
    subscribe(next: null | undefined, error: null | undefined, complete: () => void): Subscription;
    subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Subscription;
    subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Subscription;
    subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;
    toPromise(): Promise<T | undefined>;
    toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;
    toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;
    static create: (...args: any[]) => any;
}


export declare class ReplaySubject<T> extends Subject<T> {
    constructor(bufferSize?: number, windowTime?: number, timestampProvider?: TimestampProvider);
    protected _subscribe(subscriber: Subscriber<T>): Subscription;
    next(value: T): void;
}


export declare class Scheduler implements SchedulerLike {
    now: () => number;
    constructor(schedulerActionCtor: typeof Action, now?: () => number);
    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
    static now: () => number;
}


export declare class Subject<T> extends Observable<T> implements SubscriptionLike {
    closed: boolean;
    hasError: boolean;
    isStopped: boolean;
    observers: Observer<T>[];
    thrownError: any;
    constructor();
    protected _checkFinalizedStatuses(subscriber: Subscriber<any>): void;
    protected _innerSubscribe(subscriber: Subscriber<any>): Subscription;
    protected _subscribe(subscriber: Subscriber<T>): Subscription;
    protected _throwIfClosed(): void;
    protected _trySubscribe(subscriber: Subscriber<T>): TeardownLogic;
    asObservable(): Observable<T>;
    complete(): void;
    error(err: any): void;
    lift<R>(operator: Operator<T, R>): Observable<R>;
    next(value: T): void;
    unsubscribe(): void;
    static create: (...args: any[]) => any;
}


export declare class Subscriber<T> extends Subscription implements Observer<T> {
    protected destination: Subscriber<any> | Observer<any>;
    protected isStopped: boolean;
    constructor(destination?: Subscriber<any> | Observer<any>);
    protected _complete(): void;
    protected _error(err: any): void;
    protected _next(value: T): void;
    complete(): void;
    error(err?: any): void;
    next(value?: T): void;
    unsubscribe(): void;
    static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;
}


export declare class Subscription implements SubscriptionLike {
    closed: boolean;
    constructor(initialTeardown?: (() => void) | undefined);
    add(teardown: TeardownLogic): void;
    remove(teardown: Exclude<TeardownLogic, void>): void;
    unsubscribe(): void;
    static EMPTY: Subscription;
}


export declare class VirtualAction<T> extends AsyncAction<T> {
    protected active: boolean;
    protected index: number;
    protected scheduler: VirtualTimeScheduler;
    protected work: (this: SchedulerAction<T>, state?: T) => void;
    constructor(scheduler: VirtualTimeScheduler, work: (this: SchedulerAction<T>, state?: T) => void, index?: number);
    protected _execute(state: T, delay: number): any;
    protected recycleAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay?: number): any;
    protected requestAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay?: number): any;
    schedule(state?: T, delay?: number): Subscription;
}


export declare class VirtualTimeScheduler extends AsyncScheduler {
    frame: number;
    index: number;
    maxFrames: number;
    constructor(schedulerActionCtor?: typeof AsyncAction, maxFrames?: number);
    flush(): void;
    static frameTimeFactor: number;
}


export interface ArgumentOutOfRangeError extends Error {
}


export interface CompleteNotification {
    kind: 'C';
}


export interface CompletionObserver<T> {
    closed?: boolean;
    complete: () => void;
    error?: (err: any) => void;
    next?: (value: T) => void;
}


export interface EmptyError extends Error {
}


export interface ErrorNotification {
    error: any;
    kind: 'E';
}


export interface ErrorObserver<T> {
    closed?: boolean;
    complete?: () => void;
    error: (err: any) => void;
    next?: (value: T) => void;
}


export interface GroupedObservable<K, T> extends Observable<T> {
    readonly key: K;
}


export interface InteropObservable<T> {
    [Symbol.observable]: () => Subscribable<T>;
}


export interface MonoTypeOperatorFunction<T> extends OperatorFunction<T, T> {
}


export interface NextNotification<T> {
    kind: 'N';
    value: T;
}


export interface NextObserver<T> {
    closed?: boolean;
    complete?: () => void;
    error?: (err: any) => void;
    next: (value: T) => void;
}


export interface NotFoundError extends Error {
}


export interface ObjectUnsubscribedError extends Error {
}


export interface Observer<T> {
    closed?: boolean;
    complete: () => void;
    error: (err: any) => void;
    next: (value: T) => void;
}


export interface Operator<T, R> {
    call(subscriber: Subscriber<R>, source: any): TeardownLogic;
}


export interface OperatorFunction<T, R> extends UnaryFunction<Observable<T>, Observable<R>> {
}


export interface SchedulerAction<T> extends Subscription {
    schedule(state?: T, delay?: number): Subscription;
}


export interface SchedulerLike extends TimestampProvider {
    schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;
}


export interface SequenceError extends Error {
}


export interface Subscribable<T> {
    subscribe(observer?: PartialObserver<T>): Unsubscribable;
    subscribe(next: null | undefined, error: null | undefined, complete: () => void): Unsubscribable;
    subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Unsubscribable;
    subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Unsubscribable;
    subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Unsubscribable;
}


export interface SubscriptionLike extends Unsubscribable {
    readonly closed: boolean;
    unsubscribe(): void;
}


export interface TimeInterval<T> {
    interval: number;
    value: T;
}


export interface TimeoutError<T = unknown, M = unknown> extends Error {
    info: TimeoutInfo<T, M> | null;
}


export interface Timestamp<T> {
    timestamp: number;
    value: T;
}


export interface TimestampProvider {
    now(): number;
}


export interface UnaryFunction<T, R> {
    (source: T): R;
}


export interface Unsubscribable {
    unsubscribe(): void;
}


export interface UnsubscriptionError extends Error {
    readonly errors: any[];
}


export declare enum NotificationKind {
    NEXT = "N",
    ERROR = "E",
    COMPLETE = "C"
}


export declare type Cons<X, Y extends any[]> = ((arg: X, ...rest: Y) => any) extends (...args: infer U) => any ? U : never;


export declare type FactoryOrValue<T> = T | (() => T);


export declare type Head<X extends any[]> = ((...args: X) => any) extends (arg: infer U, ...rest: any[]) => any ? U : never;


export declare type ObservableInput<T> = Observable<T> | InteropObservable<T> | AsyncIterable<T> | PromiseLike<T> | ArrayLike<T> | Iterable<T>;


export declare type ObservableInputTuple<T> = {
    [K in keyof T]: ObservableInput<T[K]>;
};


export declare type ObservableLike<T> = InteropObservable<T>;


export declare type ObservableNotification<T> = NextNotification<T> | ErrorNotification | CompleteNotification;


export declare type ObservedValueOf<O> = O extends ObservableInput<infer T> ? T : never;


export declare type ObservedValuesFromArray<X> = ObservedValueUnionFromArray<X>;


export declare type ObservedValueTupleFromArray<X> = {
    [K in keyof X]: ObservedValueOf<X[K]>;
};


export declare type ObservedValueUnionFromArray<X> = X extends Array<ObservableInput<infer T>> ? T : never;


export declare type PartialObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>;


export declare type SubscribableOrPromise<T> = Subscribable<T> | Subscribable<never> | PromiseLike<T> | InteropObservable<T>;


export declare type Tail<X extends any[]> = ((...args: X) => any) extends (arg: any, ...rest: infer U) => any ? U : never;


export declare type TeardownLogic = Subscription | Unsubscribable | (() => void) | void;


export declare type ValueFromArray<A> = A extends Array<infer T> ? T : never;


export declare type ValueFromNotification<T> = T extends {
    kind: 'N' | 'E' | 'C';
} ? T extends NextNotification<any> ? T extends {
    value: infer V;
} ? V : undefined : never : never;


protected _checkFinalizedStatuses(subscriber: Subscriber<T>): void;


complete(): void;


next(value: T): void;


protected _subscribe(subscriber: Subscriber<T>): Subscription;


protected _teardown(): void;


connect(): Subscription;


protected getSubject(): Subject<T>;


refCount(): Observable<T>;


accept(next: (value: T) => void, error: (err: any) => void, complete: () => void): void;


accept(next: (value: T) => void, error: (err: any) => void): void;


accept(next: (value: T) => void): void;


accept(observer: PartialObserver<T>): void;


do(next: (value: T) => void, error: (err: any) => void, complete: () => void): void;


do(next: (value: T) => void, error: (err: any) => void): void;


do(next: (value: T) => void): void;


observe(observer: PartialObserver<T>): void;


toObservable(): Observable<T>;


static createComplete(): Notification<never> & CompleteNotification;


static createError(err?: any): Notification<never> & ErrorNotification;


static createNext<T>(value: T): Notification<T> & NextNotification<T>;


protected _subscribe(subscriber: Subscriber<any>): TeardownLogic;


protected _trySubscribe(sink: Subscriber<T>): TeardownLogic;


forEach(next: (value: T) => void): Promise<void>;


forEach(next: (value: T) => void, promiseCtor: PromiseConstructorLike): Promise<void>;


protected lift<R>(operator?: Operator<T, R>): Observable<R>;


pipe(): Observable<T>;


pipe<A>(op1: OperatorFunction<T, A>): Observable<A>;


pipe<A, B>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Observable<B>;


pipe<A, B, C>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Observable<C>;


pipe<A, B, C, D>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Observable<D>;


pipe<A, B, C, D, E>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Observable<E>;


pipe<A, B, C, D, E, F>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Observable<F>;


pipe<A, B, C, D, E, F, G>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Observable<G>;


pipe<A, B, C, D, E, F, G, H>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Observable<H>;


pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Observable<I>;


pipe<A, B, C, D, E, F, G, H, I>(op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, ...operations: OperatorFunction<any, any>[]): Observable<unknown>;


subscribe(observer?: PartialObserver<T>): Subscription;


subscribe(next: null | undefined, error: null | undefined, complete: () => void): Subscription;


subscribe(next: null | undefined, error: (error: any) => void, complete?: () => void): Subscription;


subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Subscription;


subscribe(next?: (value: T) => void, error?: (error: any) => void, complete?: () => void): Subscription;


toPromise(): Promise<T | undefined>;


toPromise(PromiseCtor: typeof Promise): Promise<T | undefined>;


toPromise(PromiseCtor: PromiseConstructorLike): Promise<T | undefined>;


schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay?: number, state?: T): Subscription;


protected _checkFinalizedStatuses(subscriber: Subscriber<any>): void;


protected _innerSubscribe(subscriber: Subscriber<any>): Subscription;


protected _throwIfClosed(): void;


protected _trySubscribe(subscriber: Subscriber<T>): TeardownLogic;


asObservable(): Observable<T>;


error(err: any): void;


lift<R>(operator: Operator<T, R>): Observable<R>;


unsubscribe(): void;


protected _complete(): void;


protected _error(err: any): void;


protected _next(value: T): void;


error(err?: any): void;


next(value?: T): void;


static create<T>(next?: (x?: T) => void, error?: (e?: any) => void, complete?: () => void): Subscriber<T>;


add(teardown: TeardownLogic): void;


remove(teardown: Exclude<TeardownLogic, void>): void;


protected _execute(state: T, delay: number): any;


protected recycleAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay?: number): any;


protected requestAsyncId(scheduler: VirtualTimeScheduler, id?: any, delay?: number): any;


schedule(state?: T, delay?: number): Subscription;


flush(): void;


export function isEmptyIngestionSpec(spec: IngestionSpec) {
  return Object.keys(spec).length === 0;
}


export function adjustIngestionSpec(spec: IngestionSpec) {
  if (spec.tuningConfig) {
    spec = deepSet(spec, 'tuningConfig', adjustTuningConfig(spec.tuningConfig));
  }
  return spec;
}


function ingestionTypeToIoAndTuningConfigType(ingestionType: IngestionType): string {
  switch (ingestionType) {
    case 'kafka':
    case 'kinesis':
    case 'index_parallel':
      return ingestionType;

    default:
      throw new Error(`unknown type '${ingestionType}'`);
  }
}


export function getIngestionComboType(spec: IngestionSpec): IngestionComboType | undefined {
  const ioConfig = deepGet(spec, 'ioConfig') || EMPTY_OBJECT;

  switch (ioConfig.type) {
    case 'kafka':
    case 'kinesis':
      return ioConfig.type;

    case 'index_parallel':
      const inputSource = deepGet(spec, 'ioConfig.inputSource') || EMPTY_OBJECT;
      switch (inputSource.type) {
        case 'local':
        case 'http':
        case 'druid':
        case 'inline':
        case 's3':
        case 'google':
        case 'hdfs':
          return `${ioConfig.type}:${inputSource.type}` as IngestionComboType;
      }
  }

  return;
}