/**

* @license

* Copyright 2018 Google LLC

*

* Use of this source code is governed by an MIT-style

* license that can be found in the LICENSE file or at

* https://opensource.org/licenses/MIT.

* =============================================================================

*/

/* Original source: keras/engine/topology.py */

import {DataType, Scalar, serialization, Tensor, tidy, util} from '@tensorflow/tfjs-core';

import {getNextUniqueTensorId, getUid} from '../backend/state';

import {getScopedTensorName, getUniqueTensorName, nameScope} from '../common';

import {Constraint} from '../constraints';

import {AttributeError, NotImplementedError, RuntimeError, ValueError} from '../errors';

import {getInitializer, Initializer} from '../initializers';

import {Shape} from '../keras_format/common';

import {Regularizer} from '../regularizers';

import {Kwargs, RegularizerFn} from '../types';

import * as generic_utils from '../utils/generic_utils';

import * as types_utils from '../utils/types_utils';

import * as variable_utils from '../utils/variable_utils';

import {batchGetValue, batchSetValue, LayerVariable} from '../variables';

// TODO(michaelterry): This is a stub until it's defined.

export type Op = (x: LayerVariable) => LayerVariable;

/**

* Constructor arguments for InputSpec.

*/

export interface InputSpecArgs {

}

/**

* Specifies the ndim, dtype and shape of every input to a layer.

*

* Every layer should expose (if appropriate) an `inputSpec` attribute:

* a list of instances of InputSpec (one per input tensor).

*

* A null entry in a shape is compatible with any dimension,

* a null shape is compatible with any shape.

*/

export class InputSpec {

}

/**

* `tf.SymbolicTensor` is a placeholder for a Tensor without any concrete value.

*

* They are most often encountered when building a graph of `Layer`s for a

* `tf.LayersModel` and the input data's shape, but not values are known.

*

* @doc {heading: 'Models', 'subheading': 'Classes'}

*/

export class SymbolicTensor {

}

/**

* Constructor arguments for Node.

*/

export interface NodeArgs {

}

/**

* The type of the return value of Layer.dispose() and Container.dispose().

*/

export interface DisposeResult {

}

let _nextNodeID = 0;

/**

* A `Node` describes the connectivity between two layers.

*

* Each time a layer is connected to some new input,

* a node is added to `layer.inboundNodes`.

*

* Each time the output of a layer is used by another layer,

* a node is added to `layer.outboundNodes`.

*

* `nodeIndices` and `tensorIndices` are basically fine-grained coordinates

* describing the origin of the `inputTensors`, verifying the following:

*

* `inputTensors[i] ==

* inboundLayers[i].inboundNodes[nodeIndices[i]].outputTensors[

* tensorIndices[i]]`

*

* A node from layer A to layer B is added to:

* A.outboundNodes

* B.inboundNodes

*/

export class Node {

}

/** Constructor arguments for Layer. */

export declare interface LayerArgs {

}

// If necessary, add `output` arguments to the CallHook function.

// This is currently used for testing only, but may be used for debugger-related

// purposes in the future.

export type CallHook = (inputs: Tensor|Tensor[], kwargs: Kwargs) => void;

let _nextLayerID = 0;

/**

* A layer is a grouping of operations and weights that can be composed to

* create a `tf.LayersModel`.

*

* Layers are constructed by using the functions under the

* [tf.layers](#Layers-Basic) namespace.

*

* @doc {heading: 'Layers', subheading: 'Classes', namespace: 'layers'}

*/

export abstract class Layer extends serialization.Serializable {