@dugararchit/flex-layout 13.0.0-dugararchit

package/flex/flex/flex.d.ts

@@ -0,0 +1,59 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef, OnInit } from '@angular/core';
+import { BaseDirective2, LayoutConfigOptions, StyleUtils, StyleBuilder, StyleDefinition, MediaMarshaller, ElementMatcher } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+interface FlexBuilderParent {
+    direction: string;
+    hasWrap: boolean;
+}
+export declare class FlexStyleBuilder extends StyleBuilder {
+    protected layoutConfig: LayoutConfigOptions;
+    constructor(layoutConfig: LayoutConfigOptions);
+    buildStyles(input: string, parent: FlexBuilderParent): StyleDefinition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlexStyleBuilder>;
+}
+/**
+ * Directive to control the size of a flex item using flex-basis, flex-grow, and flex-shrink.
+ * Corresponds to the css `flex` shorthand property.
+ *
+ * @see https://css-tricks.com/snippets/css/a-guide-to-flexbox/
+ */
+export declare class FlexDirective extends BaseDirective2 implements OnInit {
+    protected layoutConfig: LayoutConfigOptions;
+    protected marshal: MediaMarshaller;
+    protected DIRECTIVE_KEY: string;
+    protected direction?: string;
+    protected wrap?: boolean;
+    get shrink(): string;
+    set shrink(value: string);
+    get grow(): string;
+    set grow(value: string);
+    protected flexGrow: string;
+    protected flexShrink: string;
+    constructor(elRef: ElementRef, styleUtils: StyleUtils, layoutConfig: LayoutConfigOptions, styleBuilder: FlexStyleBuilder, marshal: MediaMarshaller);
+    ngOnInit(): void;
+    /**
+     * Caches the parent container's 'flex-direction' and updates the element's style.
+     * Used as a handler for layout change events from the parent flex container.
+     */
+    protected onLayoutChange(matcher: ElementMatcher): void;
+    /** Input to this is exclusively the basis input value */
+    protected updateWithValue(value: string): void;
+    /** Trigger a style reflow, usually based on a shrink/grow input event */
+    protected triggerReflow(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FlexDirective, never, never, { "shrink": "fxShrink"; "grow": "fxGrow"; }, {}, never>;
+}
+export declare class DefaultFlexDirective extends FlexDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultFlexDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultFlexDirective, "  [fxFlex], [fxFlex.xs], [fxFlex.sm], [fxFlex.md],  [fxFlex.lg], [fxFlex.xl], [fxFlex.lt-sm], [fxFlex.lt-md],  [fxFlex.lt-lg], [fxFlex.lt-xl], [fxFlex.gt-xs], [fxFlex.gt-sm],  [fxFlex.gt-md], [fxFlex.gt-lg]", never, { "fxFlex": "fxFlex"; "fxFlex.xs": "fxFlex.xs"; "fxFlex.sm": "fxFlex.sm"; "fxFlex.md": "fxFlex.md"; "fxFlex.lg": "fxFlex.lg"; "fxFlex.xl": "fxFlex.xl"; "fxFlex.lt-sm": "fxFlex.lt-sm"; "fxFlex.lt-md": "fxFlex.lt-md"; "fxFlex.lt-lg": "fxFlex.lt-lg"; "fxFlex.lt-xl": "fxFlex.lt-xl"; "fxFlex.gt-xs": "fxFlex.gt-xs"; "fxFlex.gt-sm": "fxFlex.gt-sm"; "fxFlex.gt-md": "fxFlex.gt-md"; "fxFlex.gt-lg": "fxFlex.gt-lg"; }, {}, never>;
+}
+export {};

package/flex/flex-align/flex-align.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef } from '@angular/core';
+import { MediaMarshaller, BaseDirective2, StyleBuilder, StyleDefinition, StyleUtils } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export declare class FlexAlignStyleBuilder extends StyleBuilder {
+    buildStyles(input: string): StyleDefinition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexAlignStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlexAlignStyleBuilder>;
+}
+/**
+ * 'flex-align' flexbox styling directive
+ * Allows element-specific overrides for cross-axis alignments in a layout container
+ * @see https://css-tricks.com/almanac/properties/a/align-self/
+ */
+export declare class FlexAlignDirective extends BaseDirective2 {
+    protected DIRECTIVE_KEY: string;
+    constructor(elRef: ElementRef, styleUtils: StyleUtils, styleBuilder: FlexAlignStyleBuilder, marshal: MediaMarshaller);
+    protected styleCache: Map<string, StyleDefinition>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexAlignDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FlexAlignDirective, never, never, {}, {}, never>;
+}
+export declare class DefaultFlexAlignDirective extends FlexAlignDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultFlexAlignDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultFlexAlignDirective, "  [fxFlexAlign], [fxFlexAlign.xs], [fxFlexAlign.sm], [fxFlexAlign.md],  [fxFlexAlign.lg], [fxFlexAlign.xl], [fxFlexAlign.lt-sm], [fxFlexAlign.lt-md],  [fxFlexAlign.lt-lg], [fxFlexAlign.lt-xl], [fxFlexAlign.gt-xs], [fxFlexAlign.gt-sm],  [fxFlexAlign.gt-md], [fxFlexAlign.gt-lg]", never, { "fxFlexAlign": "fxFlexAlign"; "fxFlexAlign.xs": "fxFlexAlign.xs"; "fxFlexAlign.sm": "fxFlexAlign.sm"; "fxFlexAlign.md": "fxFlexAlign.md"; "fxFlexAlign.lg": "fxFlexAlign.lg"; "fxFlexAlign.xl": "fxFlexAlign.xl"; "fxFlexAlign.lt-sm": "fxFlexAlign.lt-sm"; "fxFlexAlign.lt-md": "fxFlexAlign.lt-md"; "fxFlexAlign.lt-lg": "fxFlexAlign.lt-lg"; "fxFlexAlign.lt-xl": "fxFlexAlign.lt-xl"; "fxFlexAlign.gt-xs": "fxFlexAlign.gt-xs"; "fxFlexAlign.gt-sm": "fxFlexAlign.gt-sm"; "fxFlexAlign.gt-md": "fxFlexAlign.gt-md"; "fxFlexAlign.gt-lg": "fxFlexAlign.gt-lg"; }, {}, never>;
+}

package/flex/flex-fill/flex-fill.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef } from '@angular/core';
+import { BaseDirective2, StyleBuilder, StyleDefinition, StyleUtils, MediaMarshaller } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export declare class FlexFillStyleBuilder extends StyleBuilder {
+    buildStyles(_input: string): {
+        margin: number;
+        width: string;
+        height: string;
+        'min-width': string;
+        'min-height': string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexFillStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlexFillStyleBuilder>;
+}
+/**
+ * 'fxFill' flexbox styling directive
+ *  Maximizes width and height of element in a layout container
+ *
+ *  NOTE: fxFill is NOT responsive API!!
+ */
+export declare class FlexFillDirective extends BaseDirective2 {
+    constructor(elRef: ElementRef, styleUtils: StyleUtils, styleBuilder: FlexFillStyleBuilder, marshal: MediaMarshaller);
+    protected styleCache: Map<string, StyleDefinition>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexFillDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FlexFillDirective, "[fxFill], [fxFlexFill]", never, {}, {}, never>;
+}

package/flex/flex-offset/flex-offset.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef, OnChanges } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { MediaMarshaller, BaseDirective2, StyleBuilder, StyleDefinition, StyleUtils, LayoutConfigOptions } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export interface FlexOffsetParent {
+    layout: string;
+    isRtl: boolean;
+}
+export declare class FlexOffsetStyleBuilder extends StyleBuilder {
+    private _config;
+    constructor(_config: LayoutConfigOptions);
+    buildStyles(offset: string, parent: FlexOffsetParent): StyleDefinition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexOffsetStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlexOffsetStyleBuilder>;
+}
+/**
+ * 'flex-offset' flexbox styling directive
+ * Configures the 'margin-left' of the element in a layout container
+ */
+export declare class FlexOffsetDirective extends BaseDirective2 implements OnChanges {
+    protected directionality: Directionality;
+    protected DIRECTIVE_KEY: string;
+    constructor(elRef: ElementRef, directionality: Directionality, styleBuilder: FlexOffsetStyleBuilder, marshal: MediaMarshaller, styler: StyleUtils);
+    /**
+     * Using the current fxFlexOffset value, update the inline CSS
+     * NOTE: this will assign `margin-left` if the parent flex-direction == 'row',
+     *       otherwise `margin-top` is used for the offset.
+     */
+    protected updateWithValue(value?: string | number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexOffsetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FlexOffsetDirective, never, never, {}, {}, never>;
+}
+export declare class DefaultFlexOffsetDirective extends FlexOffsetDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultFlexOffsetDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultFlexOffsetDirective, "  [fxFlexOffset], [fxFlexOffset.xs], [fxFlexOffset.sm], [fxFlexOffset.md],  [fxFlexOffset.lg], [fxFlexOffset.xl], [fxFlexOffset.lt-sm], [fxFlexOffset.lt-md],  [fxFlexOffset.lt-lg], [fxFlexOffset.lt-xl], [fxFlexOffset.gt-xs], [fxFlexOffset.gt-sm],  [fxFlexOffset.gt-md], [fxFlexOffset.gt-lg]", never, { "fxFlexOffset": "fxFlexOffset"; "fxFlexOffset.xs": "fxFlexOffset.xs"; "fxFlexOffset.sm": "fxFlexOffset.sm"; "fxFlexOffset.md": "fxFlexOffset.md"; "fxFlexOffset.lg": "fxFlexOffset.lg"; "fxFlexOffset.xl": "fxFlexOffset.xl"; "fxFlexOffset.lt-sm": "fxFlexOffset.lt-sm"; "fxFlexOffset.lt-md": "fxFlexOffset.lt-md"; "fxFlexOffset.lt-lg": "fxFlexOffset.lt-lg"; "fxFlexOffset.lt-xl": "fxFlexOffset.lt-xl"; "fxFlexOffset.gt-xs": "fxFlexOffset.gt-xs"; "fxFlexOffset.gt-sm": "fxFlexOffset.gt-sm"; "fxFlexOffset.gt-md": "fxFlexOffset.gt-md"; "fxFlexOffset.gt-lg": "fxFlexOffset.gt-lg"; }, {}, never>;
+}

package/flex/flex-order/flex-order.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef, OnChanges } from '@angular/core';
+import { BaseDirective2, StyleBuilder, StyleDefinition, StyleUtils, MediaMarshaller } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export declare class FlexOrderStyleBuilder extends StyleBuilder {
+    buildStyles(value: string): {
+        order: string | number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexOrderStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FlexOrderStyleBuilder>;
+}
+/**
+ * 'flex-order' flexbox styling directive
+ * Configures the positional ordering of the element in a sorted layout container
+ * @see https://css-tricks.com/almanac/properties/o/order/
+ */
+export declare class FlexOrderDirective extends BaseDirective2 implements OnChanges {
+    protected DIRECTIVE_KEY: string;
+    constructor(elRef: ElementRef, styleUtils: StyleUtils, styleBuilder: FlexOrderStyleBuilder, marshal: MediaMarshaller);
+    protected styleCache: Map<string, StyleDefinition>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexOrderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FlexOrderDirective, never, never, {}, {}, never>;
+}
+export declare class DefaultFlexOrderDirective extends FlexOrderDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultFlexOrderDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultFlexOrderDirective, "  [fxFlexOrder], [fxFlexOrder.xs], [fxFlexOrder.sm], [fxFlexOrder.md],  [fxFlexOrder.lg], [fxFlexOrder.xl], [fxFlexOrder.lt-sm], [fxFlexOrder.lt-md],  [fxFlexOrder.lt-lg], [fxFlexOrder.lt-xl], [fxFlexOrder.gt-xs], [fxFlexOrder.gt-sm],  [fxFlexOrder.gt-md], [fxFlexOrder.gt-lg]", never, { "fxFlexOrder": "fxFlexOrder"; "fxFlexOrder.xs": "fxFlexOrder.xs"; "fxFlexOrder.sm": "fxFlexOrder.sm"; "fxFlexOrder.md": "fxFlexOrder.md"; "fxFlexOrder.lg": "fxFlexOrder.lg"; "fxFlexOrder.xl": "fxFlexOrder.xl"; "fxFlexOrder.lt-sm": "fxFlexOrder.lt-sm"; "fxFlexOrder.lt-md": "fxFlexOrder.lt-md"; "fxFlexOrder.lt-lg": "fxFlexOrder.lt-lg"; "fxFlexOrder.lt-xl": "fxFlexOrder.lt-xl"; "fxFlexOrder.gt-xs": "fxFlexOrder.gt-xs"; "fxFlexOrder.gt-sm": "fxFlexOrder.gt-sm"; "fxFlexOrder.gt-md": "fxFlexOrder.gt-md"; "fxFlexOrder.gt-lg": "fxFlexOrder.gt-lg"; }, {}, never>;
+}

package/flex/layout/layout.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef, OnChanges } from '@angular/core';
+import { BaseDirective2, StyleBuilder, StyleUtils, MediaMarshaller, LayoutConfigOptions } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export interface LayoutStyleDisplay {
+    readonly display: string;
+}
+export declare class LayoutStyleBuilder extends StyleBuilder {
+    buildStyles(input: string, { display }: LayoutStyleDisplay): {
+        display: string;
+        'box-sizing': string;
+        'flex-direction': string;
+        'flex-wrap': string | null;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutStyleBuilder>;
+}
+/**
+ * 'layout' flexbox styling directive
+ * Defines the positioning flow direction for the child elements: row or column
+ * Optional values: column or row (default)
+ * @see https://css-tricks.com/almanac/properties/f/flex-direction/
+ *
+ */
+export declare class LayoutDirective extends BaseDirective2 implements OnChanges {
+    private _config;
+    protected DIRECTIVE_KEY: string;
+    constructor(elRef: ElementRef, styleUtils: StyleUtils, styleBuilder: LayoutStyleBuilder, marshal: MediaMarshaller, _config: LayoutConfigOptions);
+    protected updateWithValue(input: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LayoutDirective, never, never, {}, {}, never>;
+}
+export declare class DefaultLayoutDirective extends LayoutDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultLayoutDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultLayoutDirective, "  [fxLayout], [fxLayout.xs], [fxLayout.sm], [fxLayout.md],  [fxLayout.lg], [fxLayout.xl], [fxLayout.lt-sm], [fxLayout.lt-md],  [fxLayout.lt-lg], [fxLayout.lt-xl], [fxLayout.gt-xs], [fxLayout.gt-sm],  [fxLayout.gt-md], [fxLayout.gt-lg]", never, { "fxLayout": "fxLayout"; "fxLayout.xs": "fxLayout.xs"; "fxLayout.sm": "fxLayout.sm"; "fxLayout.md": "fxLayout.md"; "fxLayout.lg": "fxLayout.lg"; "fxLayout.xl": "fxLayout.xl"; "fxLayout.lt-sm": "fxLayout.lt-sm"; "fxLayout.lt-md": "fxLayout.lt-md"; "fxLayout.lt-lg": "fxLayout.lt-lg"; "fxLayout.lt-xl": "fxLayout.lt-xl"; "fxLayout.gt-xs": "fxLayout.gt-xs"; "fxLayout.gt-sm": "fxLayout.gt-sm"; "fxLayout.gt-md": "fxLayout.gt-md"; "fxLayout.gt-lg": "fxLayout.gt-lg"; }, {}, never>;
+}

package/flex/layout-align/layout-align.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef } from '@angular/core';
+import { BaseDirective2, StyleBuilder, StyleDefinition, StyleUtils, MediaMarshaller, ElementMatcher } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export interface LayoutAlignParent {
+    layout: string;
+    inline: boolean;
+}
+export declare class LayoutAlignStyleBuilder extends StyleBuilder {
+    buildStyles(align: string, parent: LayoutAlignParent): StyleDefinition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutAlignStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutAlignStyleBuilder>;
+}
+/**
+ * 'layout-align' flexbox styling directive
+ *  Defines positioning of child elements along main and cross axis in a layout container
+ *  Optional values: {main-axis} values or {main-axis cross-axis} value pairs
+ *
+ *  @see https://css-tricks.com/almanac/properties/j/justify-content/
+ *  @see https://css-tricks.com/almanac/properties/a/align-items/
+ *  @see https://css-tricks.com/almanac/properties/a/align-content/
+ */
+export declare class LayoutAlignDirective extends BaseDirective2 {
+    protected DIRECTIVE_KEY: string;
+    protected layout: string;
+    protected inline: boolean;
+    constructor(elRef: ElementRef, styleUtils: StyleUtils, styleBuilder: LayoutAlignStyleBuilder, marshal: MediaMarshaller);
+    /**
+     *
+     */
+    protected updateWithValue(value: string): void;
+    /**
+     * Cache the parent container 'flex-direction' and update the 'flex' styles
+     */
+    protected onLayoutChange(matcher: ElementMatcher): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutAlignDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LayoutAlignDirective, never, never, {}, {}, never>;
+}
+export declare class DefaultLayoutAlignDirective extends LayoutAlignDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultLayoutAlignDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultLayoutAlignDirective, "  [fxLayoutAlign], [fxLayoutAlign.xs], [fxLayoutAlign.sm], [fxLayoutAlign.md],  [fxLayoutAlign.lg], [fxLayoutAlign.xl], [fxLayoutAlign.lt-sm], [fxLayoutAlign.lt-md],  [fxLayoutAlign.lt-lg], [fxLayoutAlign.lt-xl], [fxLayoutAlign.gt-xs], [fxLayoutAlign.gt-sm],  [fxLayoutAlign.gt-md], [fxLayoutAlign.gt-lg]", never, { "fxLayoutAlign": "fxLayoutAlign"; "fxLayoutAlign.xs": "fxLayoutAlign.xs"; "fxLayoutAlign.sm": "fxLayoutAlign.sm"; "fxLayoutAlign.md": "fxLayoutAlign.md"; "fxLayoutAlign.lg": "fxLayoutAlign.lg"; "fxLayoutAlign.xl": "fxLayoutAlign.xl"; "fxLayoutAlign.lt-sm": "fxLayoutAlign.lt-sm"; "fxLayoutAlign.lt-md": "fxLayoutAlign.lt-md"; "fxLayoutAlign.lt-lg": "fxLayoutAlign.lt-lg"; "fxLayoutAlign.lt-xl": "fxLayoutAlign.lt-xl"; "fxLayoutAlign.gt-xs": "fxLayoutAlign.gt-xs"; "fxLayoutAlign.gt-sm": "fxLayoutAlign.gt-sm"; "fxLayoutAlign.gt-md": "fxLayoutAlign.gt-md"; "fxLayoutAlign.gt-lg": "fxLayoutAlign.gt-lg"; }, {}, never>;
+}

package/flex/layout-gap/layout-gap.d.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef, OnDestroy, NgZone, AfterContentInit } from '@angular/core';
+import { Directionality } from '@angular/cdk/bidi';
+import { BaseDirective2, StyleBuilder, StyleDefinition, StyleUtils, MediaMarshaller, ElementMatcher, LayoutConfigOptions } from '@angular/flex-layout/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface LayoutGapParent {
+    directionality: string;
+    items: HTMLElement[];
+    layout: string;
+}
+export declare class LayoutGapStyleBuilder extends StyleBuilder {
+    private _styler;
+    private _config;
+    constructor(_styler: StyleUtils, _config: LayoutConfigOptions);
+    buildStyles(gapValue: string, parent: LayoutGapParent): StyleDefinition;
+    sideEffect(gapValue: string, _styles: StyleDefinition, parent: LayoutGapParent): void;
+    private addFallbackUnit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutGapStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LayoutGapStyleBuilder>;
+}
+/**
+ * 'layout-padding' styling directive
+ *  Defines padding of child elements in a layout container
+ */
+export declare class LayoutGapDirective extends BaseDirective2 implements AfterContentInit, OnDestroy {
+    protected zone: NgZone;
+    protected directionality: Directionality;
+    protected styleUtils: StyleUtils;
+    protected layout: string;
+    protected DIRECTIVE_KEY: string;
+    protected observerSubject: Subject<void>;
+    /** Special accessor to query for all child 'element' nodes regardless of type, class, etc */
+    protected get childrenNodes(): HTMLElement[];
+    constructor(elRef: ElementRef, zone: NgZone, directionality: Directionality, styleUtils: StyleUtils, styleBuilder: LayoutGapStyleBuilder, marshal: MediaMarshaller);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Cache the parent container 'flex-direction' and update the 'margin' styles
+     */
+    protected onLayoutChange(matcher: ElementMatcher): void;
+    /**
+     *
+     */
+    protected updateWithValue(value: string): void;
+    /** We need to override clearStyles because in most cases mru isn't populated */
+    protected clearStyles(): void;
+    /** Determine if an element will show or hide based on current activation */
+    protected willDisplay(source: HTMLElement): boolean;
+    protected buildChildObservable(): void;
+    protected observer?: MutationObserver;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LayoutGapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<LayoutGapDirective, never, never, {}, {}, never>;
+}
+export declare class DefaultLayoutGapDirective extends LayoutGapDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultLayoutGapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultLayoutGapDirective, "  [fxLayoutGap], [fxLayoutGap.xs], [fxLayoutGap.sm], [fxLayoutGap.md],  [fxLayoutGap.lg], [fxLayoutGap.xl], [fxLayoutGap.lt-sm], [fxLayoutGap.lt-md],  [fxLayoutGap.lt-lg], [fxLayoutGap.lt-xl], [fxLayoutGap.gt-xs], [fxLayoutGap.gt-sm],  [fxLayoutGap.gt-md], [fxLayoutGap.gt-lg]", never, { "fxLayoutGap": "fxLayoutGap"; "fxLayoutGap.xs": "fxLayoutGap.xs"; "fxLayoutGap.sm": "fxLayoutGap.sm"; "fxLayoutGap.md": "fxLayoutGap.md"; "fxLayoutGap.lg": "fxLayoutGap.lg"; "fxLayoutGap.xl": "fxLayoutGap.xl"; "fxLayoutGap.lt-sm": "fxLayoutGap.lt-sm"; "fxLayoutGap.lt-md": "fxLayoutGap.lt-md"; "fxLayoutGap.lt-lg": "fxLayoutGap.lt-lg"; "fxLayoutGap.lt-xl": "fxLayoutGap.lt-xl"; "fxLayoutGap.gt-xs": "fxLayoutGap.gt-xs"; "fxLayoutGap.gt-sm": "fxLayoutGap.gt-sm"; "fxLayoutGap.gt-md": "fxLayoutGap.gt-md"; "fxLayoutGap.gt-lg": "fxLayoutGap.gt-lg"; }, {}, never>;
+}

package/flex/module.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./layout/layout";
+import * as i2 from "./layout-gap/layout-gap";
+import * as i3 from "./layout-align/layout-align";
+import * as i4 from "./flex-order/flex-order";
+import * as i5 from "./flex-offset/flex-offset";
+import * as i6 from "./flex-fill/flex-fill";
+import * as i7 from "./flex-align/flex-align";
+import * as i8 from "./flex/flex";
+import * as i9 from "@angular/flex-layout/core";
+import * as i10 from "@angular/cdk/bidi";
+/**
+ * *****************************************************************
+ * Define module for the Flex API
+ * *****************************************************************
+ */
+export declare class FlexModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FlexModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FlexModule, [typeof i1.DefaultLayoutDirective, typeof i2.DefaultLayoutGapDirective, typeof i3.DefaultLayoutAlignDirective, typeof i4.DefaultFlexOrderDirective, typeof i5.DefaultFlexOffsetDirective, typeof i6.FlexFillDirective, typeof i7.DefaultFlexAlignDirective, typeof i8.DefaultFlexDirective], [typeof i9.CoreModule, typeof i10.BidiModule], [typeof i1.DefaultLayoutDirective, typeof i2.DefaultLayoutGapDirective, typeof i3.DefaultLayoutAlignDirective, typeof i4.DefaultFlexOrderDirective, typeof i5.DefaultFlexOffsetDirective, typeof i6.FlexFillDirective, typeof i7.DefaultFlexAlignDirective, typeof i8.DefaultFlexDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FlexModule>;
+}

package/flex/package.json

@@ -0,0 +1,10 @@
+{
+  "module": "../fesm2015/angular-flex-layout-flex.mjs",
+  "es2020": "../fesm2020/angular-flex-layout-flex.mjs",
+  "esm2020": "../esm2020/flex/angular-flex-layout-flex.mjs",
+  "fesm2020": "../fesm2020/angular-flex-layout-flex.mjs",
+  "fesm2015": "../fesm2015/angular-flex-layout-flex.mjs",
+  "typings": "angular-flex-layout-flex.d.ts",
+  "sideEffects": false,
+  "name": "@angular/flex-layout/flex"
+}

package/flex/public-api.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+export * from './module';
+export * from './flex/flex';
+export * from './flex-align/flex-align';
+export * from './flex-fill/flex-fill';
+export * from './flex-offset/flex-offset';
+export * from './flex-order/flex-order';
+export * from './layout/layout';
+export * from './layout-align/layout-align';
+export * from './layout-gap/layout-gap';

package/grid/README.md

@@ -0,0 +1,19 @@
+The `grid` entrypoint contains all of the CSS Grid APIs provided by the
+Layout library. This includes directives for flexbox containers like
+`gdArea` (a.k.a. `GridAreaDirective`) and children like `gdRow` 
+(a.k.a. `GdRowDirective`). The main export from this entrypoint is the 
+`GridModule` that encapsulates these directives, and can be 
+imported separately to take advantage of tree shaking.
+
+```typescript
+import {NgModule} from '@angular/core';
+import {GridModule} from '@angular/flex-layout/grid';
+
+@NgModule(({
+  imports: [
+    ... other imports here
+    GridModule,
+  ]
+}))
+export class AppModule {}
+```

package/grid/align-columns/align-columns.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef } from '@angular/core';
+import { BaseDirective2, StyleUtils, StyleBuilder, StyleDefinition, MediaMarshaller } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export interface GridAlignColumnsParent {
+    inline: boolean;
+}
+export declare class GridAlignColumnsStyleBuilder extends StyleBuilder {
+    buildStyles(input: string, parent: GridAlignColumnsParent): StyleDefinition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridAlignColumnsStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridAlignColumnsStyleBuilder>;
+}
+export declare class GridAlignColumnsDirective extends BaseDirective2 {
+    protected DIRECTIVE_KEY: string;
+    get inline(): boolean;
+    set inline(val: boolean);
+    protected _inline: boolean;
+    constructor(elementRef: ElementRef, styleBuilder: GridAlignColumnsStyleBuilder, styler: StyleUtils, marshal: MediaMarshaller);
+    protected updateWithValue(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridAlignColumnsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridAlignColumnsDirective, never, never, { "inline": "gdInline"; }, {}, never>;
+}
+/**
+ * 'column alignment' CSS Grid styling directive
+ * Configures the alignment in the column direction
+ * @see https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-19
+ * @see https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-21
+ */
+export declare class DefaultGridAlignColumnsDirective extends GridAlignColumnsDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultGridAlignColumnsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultGridAlignColumnsDirective, "  [gdAlignColumns],  [gdAlignColumns.xs], [gdAlignColumns.sm], [gdAlignColumns.md],  [gdAlignColumns.lg], [gdAlignColumns.xl], [gdAlignColumns.lt-sm],  [gdAlignColumns.lt-md], [gdAlignColumns.lt-lg], [gdAlignColumns.lt-xl],  [gdAlignColumns.gt-xs], [gdAlignColumns.gt-sm], [gdAlignColumns.gt-md],  [gdAlignColumns.gt-lg]", never, { "gdAlignColumns": "gdAlignColumns"; "gdAlignColumns.xs": "gdAlignColumns.xs"; "gdAlignColumns.sm": "gdAlignColumns.sm"; "gdAlignColumns.md": "gdAlignColumns.md"; "gdAlignColumns.lg": "gdAlignColumns.lg"; "gdAlignColumns.xl": "gdAlignColumns.xl"; "gdAlignColumns.lt-sm": "gdAlignColumns.lt-sm"; "gdAlignColumns.lt-md": "gdAlignColumns.lt-md"; "gdAlignColumns.lt-lg": "gdAlignColumns.lt-lg"; "gdAlignColumns.lt-xl": "gdAlignColumns.lt-xl"; "gdAlignColumns.gt-xs": "gdAlignColumns.gt-xs"; "gdAlignColumns.gt-sm": "gdAlignColumns.gt-sm"; "gdAlignColumns.gt-md": "gdAlignColumns.gt-md"; "gdAlignColumns.gt-lg": "gdAlignColumns.gt-lg"; }, {}, never>;
+}

package/grid/align-rows/align-rows.d.ts

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef } from '@angular/core';
+import { BaseDirective2, StyleUtils, StyleBuilder, StyleDefinition, MediaMarshaller } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export interface GridAlignRowsParent {
+    inline: boolean;
+}
+export declare class GridAlignRowsStyleBuilder extends StyleBuilder {
+    buildStyles(input: string, parent: GridAlignRowsParent): StyleDefinition;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridAlignRowsStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridAlignRowsStyleBuilder>;
+}
+export declare class GridAlignRowsDirective extends BaseDirective2 {
+    protected DIRECTIVE_KEY: string;
+    get inline(): boolean;
+    set inline(val: boolean);
+    protected _inline: boolean;
+    constructor(elementRef: ElementRef, styleBuilder: GridAlignRowsStyleBuilder, styler: StyleUtils, marshal: MediaMarshaller);
+    protected updateWithValue(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridAlignRowsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridAlignRowsDirective, never, never, { "inline": "gdInline"; }, {}, never>;
+}
+/**
+ * 'row alignment' CSS Grid styling directive
+ * Configures the alignment in the row direction
+ * @see https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-18
+ * @see https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-20
+ */
+export declare class DefaultGridAlignRowsDirective extends GridAlignRowsDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultGridAlignRowsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultGridAlignRowsDirective, "  [gdAlignRows],  [gdAlignRows.xs], [gdAlignRows.sm], [gdAlignRows.md],  [gdAlignRows.lg], [gdAlignRows.xl], [gdAlignRows.lt-sm],  [gdAlignRows.lt-md], [gdAlignRows.lt-lg], [gdAlignRows.lt-xl],  [gdAlignRows.gt-xs], [gdAlignRows.gt-sm], [gdAlignRows.gt-md],  [gdAlignRows.gt-lg]", never, { "gdAlignRows": "gdAlignRows"; "gdAlignRows.xs": "gdAlignRows.xs"; "gdAlignRows.sm": "gdAlignRows.sm"; "gdAlignRows.md": "gdAlignRows.md"; "gdAlignRows.lg": "gdAlignRows.lg"; "gdAlignRows.xl": "gdAlignRows.xl"; "gdAlignRows.lt-sm": "gdAlignRows.lt-sm"; "gdAlignRows.lt-md": "gdAlignRows.lt-md"; "gdAlignRows.lt-lg": "gdAlignRows.lt-lg"; "gdAlignRows.lt-xl": "gdAlignRows.lt-xl"; "gdAlignRows.gt-xs": "gdAlignRows.gt-xs"; "gdAlignRows.gt-sm": "gdAlignRows.gt-sm"; "gdAlignRows.gt-md": "gdAlignRows.gt-md"; "gdAlignRows.gt-lg": "gdAlignRows.gt-lg"; }, {}, never>;
+}

package/grid/angular-flex-layout-grid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@angular/flex-layout/grid" />
+export * from './public-api';

package/grid/area/area.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef } from '@angular/core';
+import { BaseDirective2, StyleUtils, MediaMarshaller, StyleBuilder, StyleDefinition } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export declare class GridAreaStyleBuilder extends StyleBuilder {
+    buildStyles(input: string): {
+        'grid-area': string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridAreaStyleBuilder, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridAreaStyleBuilder>;
+}
+export declare class GridAreaDirective extends BaseDirective2 {
+    protected DIRECTIVE_KEY: string;
+    constructor(elRef: ElementRef, styleUtils: StyleUtils, styleBuilder: GridAreaStyleBuilder, marshal: MediaMarshaller);
+    protected styleCache: Map<string, StyleDefinition>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridAreaDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridAreaDirective, never, never, {}, {}, never>;
+}
+/**
+ * 'grid-area' CSS Grid styling directive
+ * Configures the name or position of an element within the grid
+ * @see https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-27
+ */
+export declare class DefaultGridAreaDirective extends GridAreaDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultGridAreaDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultGridAreaDirective, "  [gdArea],  [gdArea.xs], [gdArea.sm], [gdArea.md], [gdArea.lg], [gdArea.xl],  [gdArea.lt-sm], [gdArea.lt-md], [gdArea.lt-lg], [gdArea.lt-xl],  [gdArea.gt-xs], [gdArea.gt-sm], [gdArea.gt-md], [gdArea.gt-lg]", never, { "gdArea": "gdArea"; "gdArea.xs": "gdArea.xs"; "gdArea.sm": "gdArea.sm"; "gdArea.md": "gdArea.md"; "gdArea.lg": "gdArea.lg"; "gdArea.xl": "gdArea.xl"; "gdArea.lt-sm": "gdArea.lt-sm"; "gdArea.lt-md": "gdArea.lt-md"; "gdArea.lt-lg": "gdArea.lt-lg"; "gdArea.lt-xl": "gdArea.lt-xl"; "gdArea.gt-xs": "gdArea.gt-xs"; "gdArea.gt-sm": "gdArea.gt-sm"; "gdArea.gt-md": "gdArea.gt-md"; "gdArea.gt-lg": "gdArea.gt-lg"; }, {}, never>;
+}

package/grid/areas/areas.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ElementRef } from '@angular/core';
+import { BaseDirective2, StyleUtils, StyleBuilder, MediaMarshaller } from '@angular/flex-layout/core';
+import * as i0 from "@angular/core";
+export interface GridAreasParent {
+    inline: boolean;
+}
+export declare class GridAreasStyleBuiler extends StyleBuilder {
+    buildStyles(input: string, parent: GridAreasParent): {
+        display: string;
+        'grid-template-areas': string;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridAreasStyleBuiler, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridAreasStyleBuiler>;
+}
+export declare class GridAreasDirective extends BaseDirective2 {
+    protected DIRECTIVE_KEY: string;
+    get inline(): boolean;
+    set inline(val: boolean);
+    protected _inline: boolean;
+    constructor(elRef: ElementRef, styleUtils: StyleUtils, styleBuilder: GridAreasStyleBuiler, marshal: MediaMarshaller);
+    protected updateWithValue(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridAreasDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<GridAreasDirective, never, never, { "inline": "gdInline"; }, {}, never>;
+}
+/**
+ * 'grid-template-areas' CSS Grid styling directive
+ * Configures the names of elements within the grid
+ * @see https://css-tricks.com/snippets/css/complete-guide-grid/#article-header-id-14
+ */
+export declare class DefaultGridAreasDirective extends GridAreasDirective {
+    protected inputs: string[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefaultGridAreasDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DefaultGridAreasDirective, "  [gdAreas],  [gdAreas.xs], [gdAreas.sm], [gdAreas.md], [gdAreas.lg], [gdAreas.xl],  [gdAreas.lt-sm], [gdAreas.lt-md], [gdAreas.lt-lg], [gdAreas.lt-xl],  [gdAreas.gt-xs], [gdAreas.gt-sm], [gdAreas.gt-md], [gdAreas.gt-lg]", never, { "gdAreas": "gdAreas"; "gdAreas.xs": "gdAreas.xs"; "gdAreas.sm": "gdAreas.sm"; "gdAreas.md": "gdAreas.md"; "gdAreas.lg": "gdAreas.lg"; "gdAreas.xl": "gdAreas.xl"; "gdAreas.lt-sm": "gdAreas.lt-sm"; "gdAreas.lt-md": "gdAreas.lt-md"; "gdAreas.lt-lg": "gdAreas.lt-lg"; "gdAreas.lt-xl": "gdAreas.lt-xl"; "gdAreas.gt-xs": "gdAreas.gt-xs"; "gdAreas.gt-sm": "gdAreas.gt-sm"; "gdAreas.gt-md": "gdAreas.gt-md"; "gdAreas.gt-lg": "gdAreas.gt-lg"; }, {}, never>;
+}